@vinicunca/perkakas 1.8.0 → 1.12.0

package/dist/slugify-DXOLjypc.d.ts

@@ -1,15 +0,0 @@
-//#region src/slugify.d.ts
-/**
- * Turn any string into a URL/DOM safe string.
- * @param str the string to slugify
- * @signature
- *  P.slugify(str)
- * @example
- *  P.slugify('FooBar'); // => 'foobar'
- *  P.slugify('This!-is*&%#@^up!'); // => 'this-is-up'
- * @category String
- */
-declare function slugify(str: string): string;
-//#endregion
-export { slugify };
-//# sourceMappingURL=slugify-DXOLjypc.d.ts.map

package/dist/slugify-DXOLjypc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slugify-DXOLjypc.d.ts","names":[],"sources":["../src/slugify.ts"],"sourcesContent":[],"mappings":";;AAUA;;;;;;;;;iBAAgB,OAAA"}

package/dist/sort-CTZy6xBq.d.cts

@@ -1,39 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { ReorderedArray } from "./reordered-array-CNK-grX0.cjs";
-
-//#region src/sort.d.ts
-
-/**
- * Sorts an array. The comparator function should accept two values at a time
- * and return a negative number if the first value is smaller, a positive number
- * if it's larger, and zero if they are equal. Sorting is based on a native
- * `sort` function.
- *
- * @param items - The array to sort.
- * @param cmp - The comparator function.
- * @signature
- *    P.sort(items, cmp)
- * @example
- *    P.sort([4, 2, 7, 5], (a, b) => a - b); // => [2, 4, 5, 7]
- * @dataFirst
- * @category Array
- */
-declare function sort<T extends IterableContainer>(items: T, cmp: (a: T[number], b: T[number]) => number): ReorderedArray<T>;
-/**
- * Sorts an array. The comparator function should accept two values at a time
- * and return a negative number if the first value is smaller, a positive number
- * if it's larger, and zero if they are equal. Sorting is based on a native
- * `sort` function.
- *
- * @param cmp - The comparator function.
- * @signature
- *    P.sort(cmp)(items)
- * @example
- *    P.pipe([4, 2, 7, 5], P.sort((a, b) => a - b)) // => [2, 4, 5, 7]
- * @dataLast
- * @category Array
- */
-declare function sort<T extends IterableContainer>(cmp: (a: T[number], b: T[number]) => number): (items: T) => ReorderedArray<T>;
-//#endregion
-export { sort };
-//# sourceMappingURL=sort-CTZy6xBq.d.cts.map

package/dist/sort-CTZy6xBq.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sort-CTZy6xBq.d.cts","names":[],"sources":["../src/sort.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmBA;;;;;;;;;AAmBA;;;;AACyB,iBApBT,IAoBS,CAAA,UApBM,iBAoBN,CAAA,CAAA,KAAA,EAnBhB,CAmBgB,EAAA,GAAA,EAAA,CAAA,CAAA,EAlBd,CAkBc,CAAA,MAAA,CAAA,EAAA,CAAA,EAlBA,CAkBA,CAAA,MAAA,CAAA,EAAA,GAAA,MAAA,CAAA,EAjBtB,cAiBsB,CAjBP,CAiBO,CAAA;;;;;;;;;;;;;;;iBADT,eAAe,4BACpB,cAAc,+BACd,MAAM,eAAe"}

package/dist/sort-CVjvrZjo.d.ts

@@ -1,39 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { ReorderedArray } from "./reordered-array-BJtughHE.js";
-
-//#region src/sort.d.ts
-
-/**
- * Sorts an array. The comparator function should accept two values at a time
- * and return a negative number if the first value is smaller, a positive number
- * if it's larger, and zero if they are equal. Sorting is based on a native
- * `sort` function.
- *
- * @param items - The array to sort.
- * @param cmp - The comparator function.
- * @signature
- *    P.sort(items, cmp)
- * @example
- *    P.sort([4, 2, 7, 5], (a, b) => a - b); // => [2, 4, 5, 7]
- * @dataFirst
- * @category Array
- */
-declare function sort<T extends IterableContainer>(items: T, cmp: (a: T[number], b: T[number]) => number): ReorderedArray<T>;
-/**
- * Sorts an array. The comparator function should accept two values at a time
- * and return a negative number if the first value is smaller, a positive number
- * if it's larger, and zero if they are equal. Sorting is based on a native
- * `sort` function.
- *
- * @param cmp - The comparator function.
- * @signature
- *    P.sort(cmp)(items)
- * @example
- *    P.pipe([4, 2, 7, 5], P.sort((a, b) => a - b)) // => [2, 4, 5, 7]
- * @dataLast
- * @category Array
- */
-declare function sort<T extends IterableContainer>(cmp: (a: T[number], b: T[number]) => number): (items: T) => ReorderedArray<T>;
-//#endregion
-export { sort };
-//# sourceMappingURL=sort-CVjvrZjo.d.ts.map

package/dist/sort-CVjvrZjo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sort-CVjvrZjo.d.ts","names":[],"sources":["../src/sort.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmBA;;;;;;;;;AAmBA;;;;AACyB,iBApBT,IAoBS,CAAA,UApBM,iBAoBN,CAAA,CAAA,KAAA,EAnBhB,CAmBgB,EAAA,GAAA,EAAA,CAAA,CAAA,EAlBd,CAkBc,CAAA,MAAA,CAAA,EAAA,CAAA,EAlBA,CAkBA,CAAA,MAAA,CAAA,EAAA,GAAA,MAAA,CAAA,EAjBtB,cAiBsB,CAjBP,CAiBO,CAAA;;;;;;;;;;;;;;;iBADT,eAAe,4BACpB,cAAc,+BACd,MAAM,eAAe"}

package/dist/sort-CaAnTT3F.cjs

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

package/dist/sort-D8s8kRLr.js

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

package/dist/sort-D8s8kRLr.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sort-D8s8kRLr.js","names":[],"sources":["../src/sort.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { ReorderedArray } from './internal/types/reordered-array';\nimport { curry } from './curry';\n\n/**\n * Sorts an array. The comparator function should accept two values at a time\n * and return a negative number if the first value is smaller, a positive number\n * if it's larger, and zero if they are equal. Sorting is based on a native\n * `sort` function.\n *\n * @param items - The array to sort.\n * @param cmp - The comparator function.\n * @signature\n *    P.sort(items, cmp)\n * @example\n *    P.sort([4, 2, 7, 5], (a, b) => a - b); // => [2, 4, 5, 7]\n * @dataFirst\n * @category Array\n */\nexport function sort<T extends IterableContainer>(\n  items: T,\n  cmp: (a: T[number], b: T[number]) => number,\n): ReorderedArray<T>;\n\n/**\n * Sorts an array. The comparator function should accept two values at a time\n * and return a negative number if the first value is smaller, a positive number\n * if it's larger, and zero if they are equal. Sorting is based on a native\n * `sort` function.\n *\n * @param cmp - The comparator function.\n * @signature\n *    P.sort(cmp)(items)\n * @example\n *    P.pipe([4, 2, 7, 5], P.sort((a, b) => a - b)) // => [2, 4, 5, 7]\n * @dataLast\n * @category Array\n */\nexport function sort<T extends IterableContainer>(\n  cmp: (a: T[number], b: T[number]) => number,\n): (items: T) => ReorderedArray<T>;\n\nexport function sort(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortImplementation, args);\n}\n\nfunction sortImplementation<T extends IterableContainer>(\n  items: T,\n  cmp: (a: T[number], b: T[number]) => number,\n): ReorderedArray<T> {\n  const ret = [...items];\n  ret.sort(cmp);\n  return ret as ReorderedArray<T>;\n}\n"],"mappings":"4CA0CA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EACP,EACA,EACmB,CACnB,IAAM,EAAM,CAAC,GAAG,EAAM,CAEtB,OADA,EAAI,KAAK,EAAI,CACN"}

package/dist/sort-by-CrMqBzvd.d.cts

@@ -1,88 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { NonEmptyArray } from "./non-empty-array-D3ZRHApS.cjs";
-import { OrderRule } from "./curry-order-rules-1zjlAgqa.cjs";
-import { ReorderedArray } from "./reordered-array-CNK-grX0.cjs";
-
-//#region src/sort-by.d.ts
-
-/**
- * Sorts `data` using the provided ordering rules. The `sort` is done via the
- * native `Array.prototype.sort` but is performed on a shallow copy of the array
- * to avoid mutating the original data.
- *
- * There are several other functions that take order rules and **bypass** the
- * need to sort the array first (in *O(nlogn)* time):
- * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
- * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
- * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
- * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
- * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
- * Refer to the docs for more details.
- *
- * @param sortRules - A variadic array of order rules defining the sorting
- * criteria. Each order rule is a projection function that extracts a comparable
- * value from the data. Sorting is based on these extracted values using the
- * native `<` and `>` operators. Earlier rules take precedence over later ones.
- * Use the syntax `[projection, "desc"]` for descending order.
- * @returns A shallow copy of the input array sorted by the provided rules.
- * @signature
- *    P.sortBy(...rules)(data)
- * @example
- *    P.pipe(
- *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
- *      P.sortBy(P.prop('a')),
- *    ); // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]
- * @dataLast
- * @category Array
- */
-declare function sortBy<T extends IterableContainer>(...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (array: T) => ReorderedArray<T>;
-/**
- * Sorts `data` using the provided ordering rules. The `sort` is done via the
- * native `Array.prototype.sort` but is performed on a shallow copy of the array
- * to avoid mutating the original data.
- *
- * There are several other functions that take order rules and **bypass** the
- * need to sort the array first (in *O(nlogn)* time):
- * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
- * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
- * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
- * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
- * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
- * Refer to the docs for more details.
- *
- * @param array - The input array.
- * @param sortRules - A variadic array of order rules defining the sorting
- * criteria. Each order rule is a projection function that extracts a comparable
- * value from the data. Sorting is based on these extracted values using the
- * native `<` and `>` operators. Earlier rules take precedence over later ones.
- * Use the syntax `[projection, "desc"]` for descending order.
- * @returns A shallow copy of the input array sorted by the provided rules.
- * @signature
- *    P.sortBy(data, ...rules)
- * @example
- *    P.sortBy(
- *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
- *      prop('a'),
- *    );  // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]
- *    P.sortBy(
- *      [
- *        {color: 'red', weight: 2},
- *        {color: 'blue', weight: 3},
- *        {color: 'green', weight: 1},
- *        {color: 'purple', weight: 1},
- *      ],
- *      [prop('weight'), 'asc'],
- *      prop('color'),
- *    ); // => [
- *    //   {color: 'green', weight: 1},
- *    //   {color: 'purple', weight: 1},
- *    //   {color: 'red', weight: 2},
- *    //   {color: 'blue', weight: 3},
- *    // ]
- * @dataFirst
- * @category Array
- */
-declare function sortBy<T extends IterableContainer>(array: T, ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): ReorderedArray<T>;
-//#endregion
-export { sortBy };
-//# sourceMappingURL=sort-by-CrMqBzvd.d.cts.map

package/dist/sort-by-CrMqBzvd.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sort-by-CrMqBzvd.d.cts","names":[],"sources":["../src/sort-by.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAqCA;;;;;;;;;;;AAkDA;;;;;;;;;;;;;;;;;iBAlDgB,iBAAiB,iCACjB,SAAS,cAAc,UAAU,uBACtC,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDhB,iBAAiB,0BACxB,iBACO,SAAS,cAAc,UAAU,eAC9C,eAAe"}

package/dist/sort-by-DBCZSbb4.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-order-rules-UcuuWkKd.cjs`);function t(...t){return e.curryOrderRules(n,t)}function n(e,t){return[...e].sort(t)}Object.defineProperty(exports,`sortBy`,{enumerable:!0,get:function(){return t}});

package/dist/sort-by-DPlbBz7L.js

@@ -1,2 +0,0 @@
-import{curryOrderRules as e}from"./curry-order-rules-BuA7D1F4.js";function t(...t){return e(n,t)}function n(e,t){return[...e].sort(t)}export{t as sortBy};
-//# sourceMappingURL=sort-by-DPlbBz7L.js.map

package/dist/sort-by-DPlbBz7L.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sort-by-DPlbBz7L.js","names":[],"sources":["../src/sort-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport type { ReorderedArray } from './internal/types/reordered-array';\nimport { curryOrderRules } from './internal/curry-order-rules';\n\n/**\n * Sorts `data` using the provided ordering rules. The `sort` is done via the\n * native `Array.prototype.sort` but is performed on a shallow copy of the array\n * to avoid mutating the original data.\n *\n * There are several other functions that take order rules and **bypass** the\n * need to sort the array first (in *O(nlogn)* time):\n * `firstBy` === `first(sortBy(data, ...rules))`, O(n).\n * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).\n * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).\n * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).\n * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).\n * Refer to the docs for more details.\n *\n * @param sortRules - A variadic array of order rules defining the sorting\n * criteria. Each order rule is a projection function that extracts a comparable\n * value from the data. Sorting is based on these extracted values using the\n * native `<` and `>` operators. Earlier rules take precedence over later ones.\n * Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A shallow copy of the input array sorted by the provided rules.\n * @signature\n *    P.sortBy(...rules)(data)\n * @example\n *    P.pipe(\n *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],\n *      P.sortBy(P.prop('a')),\n *    ); // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]\n * @dataLast\n * @category Array\n */\nexport function sortBy<T extends IterableContainer>(\n  ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (array: T) => ReorderedArray<T>;\n\n/**\n * Sorts `data` using the provided ordering rules. The `sort` is done via the\n * native `Array.prototype.sort` but is performed on a shallow copy of the array\n * to avoid mutating the original data.\n *\n * There are several other functions that take order rules and **bypass** the\n * need to sort the array first (in *O(nlogn)* time):\n * `firstBy` === `first(sortBy(data, ...rules))`, O(n).\n * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).\n * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).\n * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).\n * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).\n * Refer to the docs for more details.\n *\n * @param array - The input array.\n * @param sortRules - A variadic array of order rules defining the sorting\n * criteria. Each order rule is a projection function that extracts a comparable\n * value from the data. Sorting is based on these extracted values using the\n * native `<` and `>` operators. Earlier rules take precedence over later ones.\n * Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A shallow copy of the input array sorted by the provided rules.\n * @signature\n *    P.sortBy(data, ...rules)\n * @example\n *    P.sortBy(\n *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],\n *      prop('a'),\n *    );  // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]\n *    P.sortBy(\n *      [\n *        {color: 'red', weight: 2},\n *        {color: 'blue', weight: 3},\n *        {color: 'green', weight: 1},\n *        {color: 'purple', weight: 1},\n *      ],\n *      [prop('weight'), 'asc'],\n *      prop('color'),\n *    ); // => [\n *    //   {color: 'green', weight: 1},\n *    //   {color: 'purple', weight: 1},\n *    //   {color: 'red', weight: 2},\n *    //   {color: 'blue', weight: 3},\n *    // ]\n * @dataFirst\n * @category Array\n */\nexport function sortBy<T extends IterableContainer>(\n  array: T,\n  ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): ReorderedArray<T>;\n\nexport function sortBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRules(sortByImplementation, args);\n}\n\nfunction sortByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n): Array<T> {\n  // TODO: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.toSorted` here.\n  return [...data].sort(compareFn);\n}\n"],"mappings":"kEA4FA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAgB,EAAsB,EAAK,CAGpD,SAAS,EACP,EACA,EACU,CAEV,MAAO,CAAC,GAAG,EAAK,CAAC,KAAK,EAAU"}

package/dist/sort-by-ovbQMg9U.d.ts

@@ -1,88 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { NonEmptyArray } from "./non-empty-array-D3HWDPMt.js";
-import { OrderRule } from "./curry-order-rules-Cthu8rj4.js";
-import { ReorderedArray } from "./reordered-array-BJtughHE.js";
-
-//#region src/sort-by.d.ts
-
-/**
- * Sorts `data` using the provided ordering rules. The `sort` is done via the
- * native `Array.prototype.sort` but is performed on a shallow copy of the array
- * to avoid mutating the original data.
- *
- * There are several other functions that take order rules and **bypass** the
- * need to sort the array first (in *O(nlogn)* time):
- * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
- * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
- * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
- * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
- * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
- * Refer to the docs for more details.
- *
- * @param sortRules - A variadic array of order rules defining the sorting
- * criteria. Each order rule is a projection function that extracts a comparable
- * value from the data. Sorting is based on these extracted values using the
- * native `<` and `>` operators. Earlier rules take precedence over later ones.
- * Use the syntax `[projection, "desc"]` for descending order.
- * @returns A shallow copy of the input array sorted by the provided rules.
- * @signature
- *    P.sortBy(...rules)(data)
- * @example
- *    P.pipe(
- *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
- *      P.sortBy(P.prop('a')),
- *    ); // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]
- * @dataLast
- * @category Array
- */
-declare function sortBy<T extends IterableContainer>(...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (array: T) => ReorderedArray<T>;
-/**
- * Sorts `data` using the provided ordering rules. The `sort` is done via the
- * native `Array.prototype.sort` but is performed on a shallow copy of the array
- * to avoid mutating the original data.
- *
- * There are several other functions that take order rules and **bypass** the
- * need to sort the array first (in *O(nlogn)* time):
- * `firstBy` === `first(sortBy(data, ...rules))`, O(n).
- * `takeFirstBy` === `take(sortBy(data, ...rules), k)`, O(nlogk).
- * `dropFirstBy` === `drop(sortBy(data, ...rules), k)`, O(nlogk).
- * `nthBy` === `sortBy(data, ...rules).at(k)`, O(n).
- * `rankBy` === `sortedIndex(sortBy(data, ...rules), item)`, O(n).
- * Refer to the docs for more details.
- *
- * @param array - The input array.
- * @param sortRules - A variadic array of order rules defining the sorting
- * criteria. Each order rule is a projection function that extracts a comparable
- * value from the data. Sorting is based on these extracted values using the
- * native `<` and `>` operators. Earlier rules take precedence over later ones.
- * Use the syntax `[projection, "desc"]` for descending order.
- * @returns A shallow copy of the input array sorted by the provided rules.
- * @signature
- *    P.sortBy(data, ...rules)
- * @example
- *    P.sortBy(
- *      [{ a: 1 }, { a: 3 }, { a: 7 }, { a: 2 }],
- *      prop('a'),
- *    );  // => [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 7 }]
- *    P.sortBy(
- *      [
- *        {color: 'red', weight: 2},
- *        {color: 'blue', weight: 3},
- *        {color: 'green', weight: 1},
- *        {color: 'purple', weight: 1},
- *      ],
- *      [prop('weight'), 'asc'],
- *      prop('color'),
- *    ); // => [
- *    //   {color: 'green', weight: 1},
- *    //   {color: 'purple', weight: 1},
- *    //   {color: 'red', weight: 2},
- *    //   {color: 'blue', weight: 3},
- *    // ]
- * @dataFirst
- * @category Array
- */
-declare function sortBy<T extends IterableContainer>(array: T, ...sortRules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): ReorderedArray<T>;
-//#endregion
-export { sortBy };
-//# sourceMappingURL=sort-by-ovbQMg9U.d.ts.map

package/dist/sort-by-ovbQMg9U.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sort-by-ovbQMg9U.d.ts","names":[],"sources":["../src/sort-by.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAqCA;;;;;;;;;;;AAkDA;;;;;;;;;;;;;;;;;iBAlDgB,iBAAiB,iCACjB,SAAS,cAAc,UAAU,uBACtC,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDhB,iBAAiB,0BACxB,iBACO,SAAS,cAAc,UAAU,eAC9C,eAAe"}

package/dist/sorted-index-BFrWiZn3.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`),t=require(`./binary-search-cutoff-index-B3xuP0oe.cjs`);function n(...t){return e.curry(r,t)}function r(e,n){return t.binarySearchCutoffIndex(e,e=>e<n)}Object.defineProperty(exports,`sortedIndex`,{enumerable:!0,get:function(){return n}});

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

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

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

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

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

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

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

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

package/dist/sorted-index-DMcONUoc.js

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index-DMcONUoc.js","names":[],"sources":["../src/sorted-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 *first*\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..array.length).\n * @signature\n *    P.sortedIndex(data, item)\n * @example\n *    P.sortedIndex(['a','a','b','c','c'], 'c') // => 3\n * @dataFirst\n * @category Array\n * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndex<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 *first*\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..array.length).\n * @signature\n *    P.sortedIndex(item)(data)\n * @example\n *    P.pipe(['a','a','b','c','c'], P.sortedIndex('c')) // => 3\n * @dataLast\n * @category Array\n * @see sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy\n */\nexport function sortedIndex<T>(item: T): (data: ReadonlyArray<T>) => number;\n\nexport function sortedIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedIndexImplementation, args);\n}\n\nfunction sortedIndexImplementation<T>(\n  array: ReadonlyArray<T>,\n  item: T,\n): number {\n  return binarySearchCutoffIndex(array, (pivot) => pivot < item);\n}\n"],"mappings":"+HA8CA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EACP,EACA,EACQ,CACR,OAAO,EAAwB,EAAQ,GAAU,EAAQ,EAAK"}

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

@@ -1,70 +0,0 @@
-//#region src/sorted-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 *first*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `sortedIndex` - like this function, but doesn't take a callbackfn.
- * `sortedLastIndexBy` - like this function, but finds the last suitable index.
- * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.
- * `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.sortedIndexBy(data, item, valueFunction)
- * @example
- *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
- * @dataFirst
- * @category Array
- */
-declare function sortedIndexBy<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 *first*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `sortedIndex` - like this function, but doesn't take a callbackfn.
- * `sortedLastIndexBy` - like this function, but finds the last suitable index.
- * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.
- * `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`.
- * @signature
- *    P.sortedIndexBy(data, item, valueFunction)
- * @example
- *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
- * @dataLast
- * @category Array
- */
-declare function sortedIndexBy<T>(item: T, valueFunction: (item: T, index: number | undefined, data: ReadonlyArray<T>) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
-//#endregion
-export { sortedIndexBy };
-//# sourceMappingURL=sorted-index-by-CEUsUJdi.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index-by-CEUsUJdi.d.cts","names":[],"sources":["../src/sorted-index-by.ts"],"sourcesContent":[],"mappings":";;AAoCA;;;;;;;;;;AAyCA;;;;;;;;;;;;;;;;;;;;;;iBAzCgB,uBACR,cAAc,UACd,yBAEE,oCAEA,cAAc,OACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCS,uBACR,yBAEE,oCAEA,cAAc,OACjB,8BACG,cAAc"}

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

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";import{binarySearchCutoffIndex as t}from"./binary-search-cutoff-index-QhLfC_4-.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 sortedIndexBy};
-//# sourceMappingURL=sorted-index-by-CLUr58al.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index-by-CLUr58al.js","names":[],"sources":["../src/sorted-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 *first*\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 * `sortedIndex` - like this function, but doesn't take a callbackfn.\n * `sortedLastIndexBy` - like this function, but finds the last suitable index.\n * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.\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.sortedIndexBy(data, item, valueFunction)\n * @example\n *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataFirst\n * @category Array\n */\nexport function sortedIndexBy<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 *first*\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 * `sortedIndex` - like this function, but doesn't take a callbackfn.\n * `sortedLastIndexBy` - like this function, but finds the last suitable index.\n * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.\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 * @signature\n *    P.sortedIndexBy(data, item, valueFunction)\n * @example\n *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1\n * @dataLast\n * @category Array\n */\nexport function sortedIndexBy<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 sortedIndexBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sortedIndexByImplementation, args);\n}\n\nfunction sortedIndexByImplementation<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  const value = valueFunction(item, undefined /* index */, data);\n  return binarySearchCutoffIndex(\n    data,\n    (pivot, index) => valueFunction(pivot, index, data) < value,\n  );\n}\n"],"mappings":"+HAsFA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA6B,EAAK,CAGjD,SAAS,EACP,EACA,EACA,EAKQ,CACR,IAAM,EAAQ,EAAc,EAAM,IAAA,GAAuB,EAAK,CAC9D,OAAO,EACL,GACC,EAAO,IAAU,EAAc,EAAO,EAAO,EAAK,CAAG,EACvD"}

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

@@ -1,70 +0,0 @@
-//#region src/sorted-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 *first*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `sortedIndex` - like this function, but doesn't take a callbackfn.
- * `sortedLastIndexBy` - like this function, but finds the last suitable index.
- * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.
- * `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.sortedIndexBy(data, item, valueFunction)
- * @example
- *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
- * @dataFirst
- * @category Array
- */
-declare function sortedIndexBy<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 *first*
- * occurrence of the item.
- *
- * Runs in O(logN) time.
- *
- * See also:
- * `findIndex` - scans a possibly unsorted array in-order (linear search).
- * `sortedIndex` - like this function, but doesn't take a callbackfn.
- * `sortedLastIndexBy` - like this function, but finds the last suitable index.
- * `sortedLastIndex` - like `sortedIndex`, but finds the last suitable index.
- * `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`.
- * @signature
- *    P.sortedIndexBy(data, item, valueFunction)
- * @example
- *    P.sortedIndexBy([{age:20},{age:22}],{age:21},prop('age')) // => 1
- * @dataLast
- * @category Array
- */
-declare function sortedIndexBy<T>(item: T, valueFunction: (item: T, index: number | undefined, data: ReadonlyArray<T>) => NonNullable<unknown>): (data: ReadonlyArray<T>) => number;
-//#endregion
-export { sortedIndexBy };
-//# sourceMappingURL=sorted-index-by-CyQx_bQb.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index-by-CyQx_bQb.d.ts","names":[],"sources":["../src/sorted-index-by.ts"],"sourcesContent":[],"mappings":";;AAoCA;;;;;;;;;;AAyCA;;;;;;;;;;;;;;;;;;;;;;iBAzCgB,uBACR,cAAc,UACd,yBAEE,oCAEA,cAAc,OACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCS,uBACR,yBAEE,oCAEA,cAAc,OACjB,8BACG,cAAc"}

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

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`),t=require(`./binary-search-cutoff-index-B3xuP0oe.cjs`);function n(...t){return e.curry(r,t)}function r(e,n,r){let i=r(n,void 0,e);return t.binarySearchCutoffIndex(e,(t,n)=>r(t,n,e)<i)}Object.defineProperty(exports,`sortedIndexBy`,{enumerable:!0,get:function(){return n}});