@vinicunca/perkakas 1.8.0 → 1.12.0

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

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./binary-search-cutoff-index-QhLfC_4-.js";import{sortedLastIndexBy as e}from"./sorted-last-index-by-BGr5WioW.js";export{e as sortedLastIndexBy};
+import{t as e}from"./curry-BcQ8Up1_.js";import{t}from"./binary-search-cutoff-index-yQ2qcJHb.js";function n(...t){return e(r,t)}function r(e,n,r){let i=r(n,void 0,e);return t(e,(t,n)=>r(t,n,e)<=i)}export{n as sortedLastIndexBy};
+//# sourceMappingURL=sorted-last-index-by.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-last-index-by.js","names":[],"sources":["../src/sorted-last-index-by.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 using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * 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 * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedLastIndex` - a simplified version of this function, without a callbackfn.\n * `sortedIndexBy` - like this function, but returns the first suitable index.\n * `sortedIndex` - like `sortedLastIndex` but without a callbackfn.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param data - The (ascending) sorted array.\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    P.sortedLastIndexBy(data, item, valueFunction)\n * @example\n *    P.sortedLastIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataFirst\n * @category Array\n */\nexport function sortedLastIndexBy<T>(\n  data: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number;\n\n/**\n * Find the insertion position (index) of an item in an array with items sorted\n * in ascending order using a value function; so that\n * `splice(sortedIndex, 0, item)` would result in maintaining the arrays sort-\n * 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 * See also:\n * `findIndex` - scans a possibly unsorted array in-order (linear search).\n * `sortedLastIndex` - a simplified version of this function, without a callbackfn.\n * `sortedIndexBy` - like this function, but returns the first suitable index.\n * `sortedIndex` - like `sortedLastIndex` but without a callbackfn.\n * `rankBy` - scans a possibly unsorted array in-order, returning the index based on a sorting criteria.\n *\n * @param item - The item to insert.\n * @param valueFunction - All comparisons would be performed on the result of\n * calling this function on each compared item. Preferably this function should\n * return a `number` or `string`. This function should be the same as the one\n * provided to sortBy to sort the array. The function is called exactly once on\n * each items that is compared against in the array, and once at the beginning\n * on `item`. When called on `item` the `index` argument is `undefined`.\n * @returns Insertion index (In the range 0..data.length).\n * @signature\n *    P.sortedLastIndexBy(item, valueFunction)(data)\n * @example\n *    P.pipe([{age:20},{age:22}],sortedLastIndexBy({age:21},prop('age'))) // => 1\n * @dataLast\n * @category Array\n * @see sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex\n */\nexport function sortedLastIndexBy<T>(\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): (data: ReadonlyArray<T>) => number;\n\nexport function sortedLastIndexBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedLastIndexByImplementation, args);\n}\n\nfunction sortedLastIndexByImplementation<T>(\n  array: ReadonlyArray<T>,\n  item: T,\n  valueFunction: (\n    item: T,\n    index: number | undefined,\n    data: ReadonlyArray<T>,\n  ) => NonNullable<unknown>,\n): number {\n  const value = valueFunction(item, undefined /* index */, array);\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, index) => valueFunction(pivot, index, array) <= value,\n  );\n}\n"],"mappings":"gGAwFA,SAAgB,EAAkB,GAAG,EAAuC,CAC1E,OAAO,EAAM,EAAiC,EAAK,CAGrD,SAAS,EACP,EACA,EACA,EAKQ,CACR,IAAM,EAAQ,EAAc,EAAM,IAAA,GAAuB,EAAM,CAC/D,OAAO,EACL,GAIC,EAAO,IAAU,EAAc,EAAO,EAAO,EAAM,EAAI,EACzD"}

package/dist/sorted-last-index.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./binary-search-cutoff-index-B3xuP0oe.cjs`);const e=require(`./sorted-last-index-CdPROn6x.cjs`);exports.sortedLastIndex=e.sortedLastIndex;
+const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./binary-search-cutoff-index-ClkmTCR5.cjs`);function n(...t){return e.t(r,t)}function r(e,n){return t.t(e,e=>e<=n)}exports.sortedLastIndex=n;

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

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

@@ -0,0 +1 @@
+{"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,2 +1,45 @@
-import { sortedLastIndex } from "./sorted-last-index-DnqTn-Ev.js";
-export { sortedLastIndex };
+//#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

@@ -0,0 +1 @@
+{"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/sorted-last-index.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./binary-search-cutoff-index-QhLfC_4-.js";import{sortedLastIndex as e}from"./sorted-last-index-B4zg__sQ.js";export{e as sortedLastIndex};
+import{t as e}from"./curry-BcQ8Up1_.js";import{t}from"./binary-search-cutoff-index-yQ2qcJHb.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.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sorted-last-index.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":"gGA8CA,SAAgB,EAAgB,GAAG,EAAuC,CACxE,OAAO,EAAM,EAA+B,EAAK,CAGnD,SAAS,EACP,EACA,EACQ,CACR,OAAO,EACL,EAIC,GAAU,GAAS,EACrB"}

package/dist/splice.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./splice-BwsAFdV8.cjs`);exports.splice=e.splice;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t,n,r){let i=[...e];return i.splice(t,n,...r),i}exports.splice=t;

package/dist/splice.d.cts

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

@@ -0,0 +1 @@
+{"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,2 +1,35 @@
-import { splice } from "./splice-CRabhu-x.js";
-export { splice };
+//#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

@@ -0,0 +1 @@
+{"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/splice.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{splice as e}from"./splice-DCOBlrIJ.js";export{e as splice};
+import{t as e}from"./curry-BcQ8Up1_.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.js.map

package/dist/splice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splice.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":"wCA4CA,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/split-at.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./split-at-DUSqIHw-.cjs`);exports.splitAt=e.splitAt;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n=Math.max(Math.min(t<0?e.length+t:t,e.length),0);return[e.slice(0,n),e.slice(n)]}exports.splitAt=t;

package/dist/split-at.d.cts

@@ -1,2 +1,31 @@
-import { splitAt } from "./split-at-CU-3otme.cjs";
-export { splitAt };
+//#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

@@ -0,0 +1 @@
+{"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,2 +1,31 @@
-import { splitAt } from "./split-at-B3v6wCCc.js";
-export { splitAt };
+//#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

@@ -0,0 +1 @@
+{"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-at.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{splitAt as e}from"./split-at-vzCujYHL.js";export{e as splitAt};
+import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){let n=Math.max(Math.min(t<0?e.length+t:t,e.length),0);return[e.slice(0,n),e.slice(n)]}export{t as splitAt};
+//# sourceMappingURL=split-at.js.map

package/dist/split-at.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-at.js","names":[],"sources":["../src/split-at.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Splits a given array at a given index.\n *\n * @param array - The array to split.\n * @param index - The index to split at.\n * @signature\n *    P.splitAt(array, index)\n * @example\n *    P.splitAt([1, 2, 3], 1) // => [[1], [2, 3]]\n *    P.splitAt([1, 2, 3, 4, 5], -1) // => [[1, 2, 3, 4], [5]]\n * @dataFirst\n * @category Array\n */\nexport function splitAt<T>(\n  array: ReadonlyArray<T>,\n  index: number,\n): [Array<T>, Array<T>];\n\n/**\n * Splits a given array at a given index.\n *\n * @param index - The index to split at.\n * @signature\n *    P.splitAt(index)(array)\n * @example\n *    P.splitAt(1)([1, 2, 3]) // => [[1], [2, 3]]\n *    P.splitAt(-1)([1, 2, 3, 4, 5]) // => [[1, 2, 3, 4], [5]]\n * @dataLast\n * @category Array\n */\nexport function splitAt<T>(\n  index: number,\n): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];\n\nexport function splitAt(...args: ReadonlyArray<unknown>): unknown {\n  return curry(splitAtImplementation, args);\n}\n\nfunction splitAtImplementation<T>(\n  array: ReadonlyArray<T>,\n  index: number,\n): [Array<T>, Array<T>] {\n  const effectiveIndex = Math.max(\n    Math.min(index < 0 ? array.length + index : index, array.length),\n    0,\n  );\n  return [array.slice(0, effectiveIndex), array.slice(effectiveIndex)];\n}\n"],"mappings":"wCAoCA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EACsB,CACtB,IAAM,EAAiB,KAAK,IAC1B,KAAK,IAAI,EAAQ,EAAI,EAAM,OAAS,EAAQ,EAAO,EAAM,OAAO,CAChE,EACD,CACD,MAAO,CAAC,EAAM,MAAM,EAAG,EAAe,CAAE,EAAM,MAAM,EAAe,CAAC"}

package/dist/split-when.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./split-when-CCi2Wq1B.cjs`);exports.splitWhen=e.splitWhen;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n=e.findIndex(t);return n===-1?[[...e],[]]:[e.slice(0,n),e.slice(n)]}exports.splitWhen=t;

package/dist/split-when.d.cts

@@ -1,2 +1,29 @@
-import { splitWhen } from "./split-when-DaTD5jVa.cjs";
-export { splitWhen };
+//#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

@@ -0,0 +1 @@
+{"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,2 +1,29 @@
-import { splitWhen } from "./split-when-BTekNxF-.js";
-export { splitWhen };
+//#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

@@ -0,0 +1 @@
+{"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-when.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{splitWhen as e}from"./split-when-C7OSEoW3.js";export{e as splitWhen};
+import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){let n=e.findIndex(t);return n===-1?[[...e],[]]:[e.slice(0,n),e.slice(n)]}export{t as splitWhen};
+//# sourceMappingURL=split-when.js.map

package/dist/split-when.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-when.js","names":[],"sources":["../src/split-when.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Splits a given array at the first index where the given predicate returns true.\n *\n * @param data - The array to split.\n * @param predicate - The predicate.\n * @signature\n *    P.splitWhen(array, fn)\n * @example\n *    P.splitWhen([1, 2, 3], x => x === 2) // => [[1], [2, 3]]\n * @dataFirst\n * @category Array\n */\nexport function splitWhen<T>(\n  data: ReadonlyArray<T>,\n  predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean,\n): [Array<T>, Array<T>];\n\n/**\n * Splits a given array at an index where the given predicate returns true.\n *\n * @param predicate - The predicate.\n * @signature\n *    P.splitWhen(fn)(array)\n * @example\n *    P.splitWhen(x => x === 2)([1, 2, 3]) // => [[1], [2, 3]]\n * @dataLast\n * @category Array\n */\nexport function splitWhen<T>(\n  predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (array: ReadonlyArray<T>) => [Array<T>, Array<T>];\n\nexport function splitWhen(...args: ReadonlyArray<unknown>): unknown {\n  return curry(splitWhenImplementation, args);\n}\n\nfunction splitWhenImplementation<T>(\n  data: ReadonlyArray<T>,\n  predicate: (item: T, index: number, data: ReadonlyArray<T>) => boolean,\n): [Array<T>, Array<T>] {\n  const index = data.findIndex(predicate);\n  return index === -1\n    ? [[...data], []]\n    : [data.slice(0, index), data.slice(index)];\n}\n"],"mappings":"wCAkCA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACsB,CACtB,IAAM,EAAQ,EAAK,UAAU,EAAU,CACvC,OAAO,IAAU,GACb,CAAC,CAAC,GAAG,EAAK,CAAE,EAAE,CAAC,CACf,CAAC,EAAK,MAAM,EAAG,EAAM,CAAE,EAAK,MAAM,EAAM,CAAC"}

package/dist/split.cjs

@@ -1 +1 @@
-const e=require(`./split-Bs-frJ_a.cjs`);exports.split=e.split;
+function e(e,t,n){return typeof t==`number`||t===void 0?n=>n.split(e,t):e.split(t,n)}exports.split=e;

package/dist/split.d.cts

@@ -1,2 +1,62 @@
-import { split } from "./split-BSiis5Fh.cjs";
-export { split };
+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.d.cts.map

package/dist/split.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split.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;;;;;;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,2 +1,62 @@
-import { split } from "./split-BMnz50TJ.js";
-export { split };
+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.d.ts.map

package/dist/split.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split.d.ts","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;;;;;;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.js

@@ -1 +1,2 @@
-import{split as e}from"./split-D1qUxipp.js";export{e as split};
+function e(e,t,n){return typeof t==`number`||t===void 0?n=>n.split(e,t):e.split(t,n)}export{e as split};
+//# sourceMappingURL=split.js.map

package/dist/split.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"split.js","names":[],"sources":["../src/split.ts"],"sourcesContent":["import type {\n  ArraySlice,\n  IsFloat,\n  NonNegative,\n  Split as SplitBase,\n} from 'type-fest';\n\ntype Split<\n  S extends string,\n  Separator extends string,\n  N extends number | undefined = undefined,\n> = string extends S\n  ? Array<string>\n  : string extends Separator\n    ? Array<string>\n    : number extends N\n      ? Array<string>\n      : // TODO: We need a way to \"floor\" non-integer numbers, until then we return a lower fidelity type instead.\n      IsFloat<N> extends true\n        ? Array<string>\n        : ArraySlice<\n            // We can use the base (type-fest) split **only** if all the params\n            // are literals. For all other cases it would return the wrong type\n            // so we fallback to the built-in Array.prototype.split return type.\n            SplitBase<S, Separator>,\n            0,\n            // `undefined` and negative numbers are treated as non-limited\n            // splits, which is what we'd get when using `never` for ArraySlice.\n            N extends number ? NonNegative<N> : never\n          >;\n\n/**\n * Takes a pattern and divides this string into an ordered list of substrings by\n * searching for the pattern, puts these substrings into an array, and returns\n * 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)\n * method.\n *\n * @param data - The string to split.\n * @param separator - The pattern describing where each split should occur. Can\n * be a string, or a regular expression.\n * @param limit - A non-negative integer specifying a limit on the number of\n * substrings to be included in the array. If provided, splits the string at\n * each occurrence of the specified separator, but stops when limit entries have\n * been placed in the array. Any leftover text is not included in the array at\n * all. The array may contain fewer entries than limit if the end of the string\n * is reached before the limit is reached. If limit is 0, [] is returned.\n * @returns An Array of strings, split at each point where the separator occurs\n * in the given string.\n * @signature\n *   R.split(data, separator, limit);\n * @example\n *   R.split(\"a,b,c\", \",\"); //=> [\"a\", \"b\", \"c\"]\n *   R.split(\"a,b,c\", \",\", 2); //=> [\"a\", \"b\"]\n *   R.split(\"a1b2c3d\", /\\d/u); //=> [\"a\", \"b\", \"c\", \"d\"]\n * @dataFirst\n * @category String\n */\nexport function split(\n  data: string,\n  separator: RegExp,\n  limit?: number,\n): Array<string>;\nexport function split<\n  S extends string,\n  Separator extends string,\n  N extends number | undefined = undefined,\n>(data: S, separator: Separator, limit?: N): Split<S, Separator, N>;\n\n/**\n * Takes a pattern and divides this string into an ordered list of substrings by\n * searching for the pattern, puts these substrings into an array, and returns\n * 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)\n * method.\n *\n * @param separator - The pattern describing where each split should occur. Can\n * be a string, or a regular expression.\n * @param limit - A non-negative integer specifying a limit on the number of\n * substrings to be included in the array. If provided, splits the string at\n * each occurrence of the specified separator, but stops when limit entries have\n * been placed in the array. Any leftover text is not included in the array at\n * all. The array may contain fewer entries than limit if the end of the string\n * is reached before the limit is reached. If limit is 0, [] is returned.\n * @returns An Array of strings, split at each point where the separator occurs\n * in the given string.\n * @signature\n *   R.split(separator, limit)(data);\n * @example\n *   R.pipe(\"a,b,c\", R.split(\",\")); //=> [\"a\", \"b\", \"c\"]\n *   R.pipe(\"a,b,c\", R.split(\",\", 2)); //=> [\"a\", \"b\"]\n *   R.pipe(\"a1b2c3d\", R.split(/\\d/u)); //=> [\"a\", \"b\", \"c\", \"d\"]\n * @dataLast\n * @category String\n */\nexport function split(\n  separator: RegExp,\n  limit?: number,\n): (data: string) => Array<string>;\nexport function split<\n  S extends string,\n  Separator extends string,\n  N extends number | undefined = undefined,\n>(separator: Separator, limit?: N): (data: S) => Split<S, Separator, N>;\n\nexport function split(\n  dataOrSeparator: RegExp | string,\n  separatorOrLimit?: RegExp | number | string,\n  limit?: number,\n): unknown {\n  return typeof separatorOrLimit === 'number' || separatorOrLimit === undefined\n    // dataLast\n    ? (data: string) => data.split(dataOrSeparator, separatorOrLimit)\n    // dataFirst\n    : (dataOrSeparator as string).split(separatorOrLimit, limit);\n}\n"],"mappings":"AAuGA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAqB,UAAY,IAAqB,IAAA,GAE/D,GAAiB,EAAK,MAAM,EAAiB,EAAiB,CAE9D,EAA2B,MAAM,EAAkB,EAAM"}

package/dist/string-to-path.cjs

@@ -1 +1 @@
-const e=require(`./string-to-path-Q_OMxElX.cjs`);exports.stringToPath=e.stringToPath;
+const e=/^(?:0|[1-9]\d*)$/u;function t(n){let r=[],i=/\.{0,4096}(?<propName>[^.[\]]+)|\['(?<quoted>.{0,4096}?)'\]|\["(?<doubleQuoted>.{0,4096}?)"\]|\[(?<unquoted>.{0,4096}?)\]/uy,a;for(;(a=i.exec(n))!==null;){let{propName:n,quoted:i,doubleQuoted:o,unquoted:s}=a.groups;if(s!==void 0){r.push(...t(s));continue}r.push(n===void 0?i??o:e.test(n)?Number(n):n)}return r}exports.stringToPath=t;