@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/slice-string-C_sr11Yl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"slice-string-C_sr11Yl.js","names":[],"sources":["../src/slice-string.ts"],"sourcesContent":["/**\n * Extracts a section of this string and returns it as a new string, without\n * modifying the original string. Equivalent to `String.prototype.slice`.\n *\n * @param data - The string to extract from.\n * @param indexStart - The index of the first character to include in the\n * returned substring.\n * @param indexEnd - The index of the first character to exclude from the\n * returned substring.\n * @returns A new string containing the extracted section of the string.\n * @signature\n *    P.sliceString(data, indexStart, indexEnd)\n * @example\n *    P.sliceString(\"abcdefghijkl\", 1) // => `bcdefghijkl`\n *    P.sliceString(\"abcdefghijkl\", 4, 7) // => `efg`\n * @dataLast\n * @category String\n */\nexport function sliceString(\n  data: string,\n  indexStart: number,\n  indexEnd?: number,\n): string;\n\n/**\n * Extracts a section of this string and returns it as a new string, without\n * modifying the original string. Equivalent to `String.prototype.slice`.\n *\n * @param indexStart - The index of the first character to include in the\n * returned substring.\n * @param indexEnd - The index of the first character to exclude from the\n * returned substring, or `undefined` for the rest of the string.\n * @returns A new string containing the extracted section of the string.\n * @signature\n *    P.sliceString(indexStart, indexEnd)(string)\n * @example\n *    P.sliceString(1)(\"abcdefghijkl\") // => `bcdefghijkl`\n *    P.sliceString(4, 7)(\"abcdefghijkl\") // => `efg`\n * @dataLast\n * @category String\n */\nexport function sliceString(\n  indexStart: number,\n  indexEnd?: number,\n): (data: string) => string;\n\nexport function sliceString(\n  dataOrIndexStart: number | string,\n  indexStartOrIndexEnd?: number,\n  indexEnd?: number,\n): unknown {\n  return typeof dataOrIndexStart === 'string'\n    ? dataOrIndexStart.slice(indexStartOrIndexEnd, indexEnd)\n    : (data: string) => data.slice(dataOrIndexStart, indexStartOrIndexEnd);\n}\n"],"mappings":"AA8CA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAqB,SAC/B,EAAiB,MAAM,EAAsB,EAAS,CACrD,GAAiB,EAAK,MAAM,EAAkB,EAAqB"}

package/dist/slice-string-DDjoN-CB.d.cts

@@ -1,41 +0,0 @@
-//#region src/slice-string.d.ts
-/**
- * Extracts a section of this string and returns it as a new string, without
- * modifying the original string. Equivalent to `String.prototype.slice`.
- *
- * @param data - The string to extract from.
- * @param indexStart - The index of the first character to include in the
- * returned substring.
- * @param indexEnd - The index of the first character to exclude from the
- * returned substring.
- * @returns A new string containing the extracted section of the string.
- * @signature
- *    P.sliceString(data, indexStart, indexEnd)
- * @example
- *    P.sliceString("abcdefghijkl", 1) // => `bcdefghijkl`
- *    P.sliceString("abcdefghijkl", 4, 7) // => `efg`
- * @dataLast
- * @category String
- */
-declare function sliceString(data: string, indexStart: number, indexEnd?: number): string;
-/**
- * Extracts a section of this string and returns it as a new string, without
- * modifying the original string. Equivalent to `String.prototype.slice`.
- *
- * @param indexStart - The index of the first character to include in the
- * returned substring.
- * @param indexEnd - The index of the first character to exclude from the
- * returned substring, or `undefined` for the rest of the string.
- * @returns A new string containing the extracted section of the string.
- * @signature
- *    P.sliceString(indexStart, indexEnd)(string)
- * @example
- *    P.sliceString(1)("abcdefghijkl") // => `bcdefghijkl`
- *    P.sliceString(4, 7)("abcdefghijkl") // => `efg`
- * @dataLast
- * @category String
- */
-declare function sliceString(indexStart: number, indexEnd?: number): (data: string) => string;
-//#endregion
-export { sliceString };
-//# sourceMappingURL=slice-string-DDjoN-CB.d.cts.map

package/dist/slice-string-DDjoN-CB.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slice-string-DDjoN-CB.d.cts","names":[],"sources":["../src/slice-string.ts"],"sourcesContent":[],"mappings":";;AAkBA;AAuBA;;;;;;;;;;;;;;;;iBAvBgB,WAAA;;;;;;;;;;;;;;;;;;iBAuBA,WAAA"}

package/dist/slice-string-T3sXkO_K.cjs

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

package/dist/slice-string-e2668-0a.d.ts

@@ -1,41 +0,0 @@
-//#region src/slice-string.d.ts
-/**
- * Extracts a section of this string and returns it as a new string, without
- * modifying the original string. Equivalent to `String.prototype.slice`.
- *
- * @param data - The string to extract from.
- * @param indexStart - The index of the first character to include in the
- * returned substring.
- * @param indexEnd - The index of the first character to exclude from the
- * returned substring.
- * @returns A new string containing the extracted section of the string.
- * @signature
- *    P.sliceString(data, indexStart, indexEnd)
- * @example
- *    P.sliceString("abcdefghijkl", 1) // => `bcdefghijkl`
- *    P.sliceString("abcdefghijkl", 4, 7) // => `efg`
- * @dataLast
- * @category String
- */
-declare function sliceString(data: string, indexStart: number, indexEnd?: number): string;
-/**
- * Extracts a section of this string and returns it as a new string, without
- * modifying the original string. Equivalent to `String.prototype.slice`.
- *
- * @param indexStart - The index of the first character to include in the
- * returned substring.
- * @param indexEnd - The index of the first character to exclude from the
- * returned substring, or `undefined` for the rest of the string.
- * @returns A new string containing the extracted section of the string.
- * @signature
- *    P.sliceString(indexStart, indexEnd)(string)
- * @example
- *    P.sliceString(1)("abcdefghijkl") // => `bcdefghijkl`
- *    P.sliceString(4, 7)("abcdefghijkl") // => `efg`
- * @dataLast
- * @category String
- */
-declare function sliceString(indexStart: number, indexEnd?: number): (data: string) => string;
-//#endregion
-export { sliceString };
-//# sourceMappingURL=slice-string-e2668-0a.d.ts.map

package/dist/slice-string-e2668-0a.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slice-string-e2668-0a.d.ts","names":[],"sources":["../src/slice-string.ts"],"sourcesContent":[],"mappings":";;AAkBA;AAuBA;;;;;;;;;;;;;;;;iBAvBgB,WAAA;;;;;;;;;;;;;;;;;;iBAuBA,WAAA"}

package/dist/slugify-02-IFAOz.cjs

@@ -1 +0,0 @@
-function e(e){return e.normalize(`NFD`).replace(/[\u0300-\u036F]/g,``).toLowerCase().replace(/[^a-z0-9]/g,` `).trim().replace(/\s+/g,`-`)}Object.defineProperty(exports,`slugify`,{enumerable:!0,get:function(){return e}});

package/dist/slugify-BdGkKaj7.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-BdGkKaj7.d.ts.map

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

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

package/dist/slugify-CEC6lPso.js

@@ -1,2 +0,0 @@
-function e(e){return e.normalize(`NFD`).replace(/[\u0300-\u036F]/g,``).toLowerCase().replace(/[^a-z0-9]/g,` `).trim().replace(/\s+/g,`-`)}export{e as slugify};
-//# sourceMappingURL=slugify-CEC6lPso.js.map

package/dist/slugify-CEC6lPso.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"slugify-CEC6lPso.js","names":[],"sources":["../src/slugify.ts"],"sourcesContent":["/**\n * Turn any string into a URL/DOM safe string.\n * @param str the string to slugify\n * @signature\n *  P.slugify(str)\n * @example\n *  P.slugify('FooBar'); // => 'foobar'\n *  P.slugify('This!-is*&%#@^up!'); // => 'this-is-up'\n * @category String\n */\nexport function slugify(str: string): string {\n  return str\n    .normalize('NFD')\n    .replace(/[\\u0300-\\u036F]/g, '')\n    .toLowerCase()\n    .replace(/[^a-z0-9]/g, ' ')\n    .trim()\n    .replace(/\\s+/g, '-');\n}\n"],"mappings":"AAUA,SAAgB,EAAQ,EAAqB,CAC3C,OAAO,EACJ,UAAU,MAAM,CAChB,QAAQ,mBAAoB,GAAG,CAC/B,aAAa,CACb,QAAQ,aAAc,IAAI,CAC1B,MAAM,CACN,QAAQ,OAAQ,IAAI"}

package/dist/slugify-DVioAYr7.d.cts

@@ -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-DVioAYr7.d.cts.map

package/dist/slugify-DVioAYr7.d.cts.map

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

package/dist/sort-BZjbaFeJ.d.cts

@@ -1,39 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { ReorderedArray } from "./reordered-array-ikr9o4WE.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-BZjbaFeJ.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sort-BZjbaFeJ.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-BgfyDhxW.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-BpxPLnEH.d.ts

@@ -1,39 +0,0 @@
-import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
-import { ReorderedArray } from "./reordered-array-BJFUtOkp.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-BpxPLnEH.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sort-BpxPLnEH.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-D6nlyfod.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-D6nlyfod.js.map

package/dist/sort-D6nlyfod.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sort-D6nlyfod.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-8to821Mp.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-8to821Mp.js.map

package/dist/sort-by-8to821Mp.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sort-by-8to821Mp.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-CH6n9bWf.d.ts

@@ -1,88 +0,0 @@
-import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
-import { NonEmptyArray } from "./non-empty-array-BfTfvDYg.js";
-import { OrderRule } from "./curry-order-rules-D2zI7gpB.js";
-import { ReorderedArray } from "./reordered-array-BJFUtOkp.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-CH6n9bWf.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sort-by-CH6n9bWf.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/sort-by-CtJoPjKN.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-DoBfFSu4.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-ikr9o4WE.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-DoBfFSu4.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sort-by-DoBfFSu4.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/sorted-index-C7n8fUow.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-C7n8fUow.d.ts.map

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

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

package/dist/sorted-index-Cb-4kSWR.js

@@ -1,2 +0,0 @@
-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 sortedIndex};
-//# sourceMappingURL=sorted-index-Cb-4kSWR.js.map

package/dist/sorted-index-Cb-4kSWR.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index-Cb-4kSWR.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-WmPsJZWy.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-WmPsJZWy.d.cts.map

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

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

package/dist/sorted-index-by-BGDi-4BL.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`),t=require(`./binary-search-cutoff-index-BZF3GL7H.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}});

package/dist/sorted-index-by-C-5Yb-j2.js

@@ -1,2 +0,0 @@
-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,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-C-5Yb-j2.js.map

package/dist/sorted-index-by-C-5Yb-j2.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sorted-index-by-C-5Yb-j2.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"}