@vinicunca/perkakas 1.15.0 → 1.16.0

package/dist/filter.js.map

@@ -1 +1 @@
-{"version":3,"file":"filter.js","names":[],"sources":["../src/filter.ts"],"sourcesContent":["import type { Writable } from 'type-fest';\nimport type { FilteredArray } from './internal/types/filtered-array';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n// When the predicate used for filter isn't refining (like a type-predicate) we\n// can narrow the result slightly if it's also trivial (it returns the same\n// result for all items). This is uncommon, but can be useful to \"short-circuit\"\n// the filter.\ntype NonRefinedFilteredArray<\n  T extends IterableContainer,\n  IsItemIncluded extends boolean,\n> = boolean extends IsItemIncluded\n  ? // We don't know which items of the array the predicate would allow in the\n// output so we can only safely say that the result is an array with items\n// from the input array.\n// TODO: Theoretically we could build an output shape that would take into account the **order** of elements in the input array by reconstructing it with every single element in it either included or not, but this type can grow to a union of as much as 2^n options which might not be usable in practice.\n  Array<T[number]>\n  : IsItemIncluded extends true\n    ? // If the predicate is always true we return a shallow copy of the array.\n  // If it was originally readonly we need to strip that away.\n    Writable<T>\n    : // If the predicate is always false we will always return an empty\n      // array.\n      [];\n\n/**\n * Creates a shallow copy of a portion of a given array, filtered down to just\n * the elements from the given array that pass the test implemented by the\n * provided function. Equivalent to `Array.prototype.filter`.\n *\n * @param data - The array to filter.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to keep the element in the resulting array, and `false`\n * otherwise. A type-predicate can also be used to narrow the result.\n * @returns A shallow copy of the given array containing just the elements that\n * pass the test. If no elements pass the test, an empty array is returned.\n * @signature\n *    filter(data, predicate)\n * @example\n *    filter([1, 2, 3], x => x % 2 === 1) // => [1, 3]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function filter<\n  T extends IterableContainer,\n  Condition extends T[number],\n>(\n  data: T,\n  predicate: (value: T[number], index: number, data: T) => value is Condition,\n): FilteredArray<T, Condition>;\nexport function filter<\n  T extends IterableContainer,\n  IsItemIncluded extends boolean,\n>(\n  data: T,\n  predicate: (value: T[number], index: number, data: T) => IsItemIncluded,\n): NonRefinedFilteredArray<T, IsItemIncluded>;\n\n/**\n * Creates a shallow copy of a portion of a given array, filtered down to just\n * the elements from the given array that pass the test implemented by the\n * provided function. Equivalent to `Array.prototype.filter`.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to keep the element in the resulting array, and `false`\n * otherwise.\n * @returns A shallow copy of the given array containing just the elements that\n * pass the test. If no elements pass the test, an empty array is returned.\n * @signature\n *    filter(predicate)(data)\n * @example\n *    pipe([1, 2, 3], filter(x => x % 2 === 1)) // => [1, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function filter<\n  T extends IterableContainer,\n  Condition extends T[number],\n>(\n  predicate: (value: T[number], index: number, data: T) => value is Condition,\n): (data: T) => FilteredArray<T, Condition>;\nexport function filter<\n  T extends IterableContainer,\n  IsItemIncluded extends boolean,\n>(\n  predicate: (value: T[number], index: number, data: T) => IsItemIncluded,\n): (data: T) => NonRefinedFilteredArray<T, IsItemIncluded>;\n\nexport function filter(...args: ReadonlyArray<unknown>): unknown {\n  return curry(filterImplementation, args, lazyImplementation);\n}\n\nfunction filterImplementation<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, array: ReadonlyArray<T>) => boolean): Array<T> {\n  return data.filter(predicate);\n}\n\nfunction lazyImplementation<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): LazyEvaluator<T> {\n  return (value, index, data) =>\n    predicate(value, index, data)\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n}\n"],"mappings":"mFA6FA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAM,EAAmB,CAG9D,SAAS,EAAwB,EAAwB,EAAoF,CAC3I,OAAO,EAAK,OAAO,EAAU,CAG/B,SAAS,EAAsB,EAA2F,CACxH,OAAQ,EAAO,EAAO,IACpB,EAAU,EAAO,EAAO,EAAK,CACzB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,CAC3C"}
+{"version":3,"file":"filter.js","names":[],"sources":["../src/filter.ts"],"sourcesContent":["import type { Writable } from 'type-fest';\nimport type { FilteredArray } from './internal/types/filtered-array';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n// When the predicate used for filter isn't refining (like a type-predicate) we\n// can narrow the result slightly if it's also trivial (it returns the same\n// result for all items). This is uncommon, but can be useful to \"short-circuit\"\n// the filter.\ntype NonRefinedFilteredArray<\n  T extends IterableContainer,\n  IsItemIncluded extends boolean,\n> = boolean extends IsItemIncluded\n  ? // We don't know which items of the array the predicate would allow in the\n// output so we can only safely say that the result is an array with items\n// from the input array.\n// TODO: Theoretically we could build an output shape that would take into account the **order** of elements in the input array by reconstructing it with every single element in it either included or not, but this type can grow to a union of as much as 2^n options which might not be usable in practice.\n  Array<T[number]>\n  : IsItemIncluded extends true\n    ? // If the predicate is always true we return a shallow copy of the array.\n  // If it was originally readonly we need to strip that away.\n    Writable<T>\n    : // If the predicate is always false we will always return an empty\n      // array.\n      [];\n\n/**\n * Creates a shallow copy of a portion of a given array, filtered down to just\n * the elements from the given array that pass the test implemented by the\n * provided function. Equivalent to `Array.prototype.filter`.\n *\n * Related operations:\n * - `splice` - to shape the array by *position* rather than by *value*.\n *\n * @param data - The array to filter.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to keep the element in the resulting array, and `false`\n * otherwise. A type-predicate can also be used to narrow the result.\n * @returns A shallow copy of the given array containing just the elements that\n * pass the test. If no elements pass the test, an empty array is returned.\n * @signature\n *    filter(data, predicate)\n * @example\n *    filter([1, 2, 3], x => x % 2 === 1) // => [1, 3]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function filter<\n  T extends IterableContainer,\n  Condition extends T[number],\n>(\n  data: T,\n  predicate: (value: T[number], index: number, data: T) => value is Condition,\n): FilteredArray<T, Condition>;\nexport function filter<\n  T extends IterableContainer,\n  IsItemIncluded extends boolean,\n>(\n  data: T,\n  predicate: (value: T[number], index: number, data: T) => IsItemIncluded,\n): NonRefinedFilteredArray<T, IsItemIncluded>;\n\n/**\n * Creates a shallow copy of a portion of a given array, filtered down to just\n * the elements from the given array that pass the test implemented by the\n * provided function. Equivalent to `Array.prototype.filter`.\n *\n * Related operations:\n * - `splice` - to shape the array by *position* rather than by *value*.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to keep the element in the resulting array, and `false`\n * otherwise.\n * @returns A shallow copy of the given array containing just the elements that\n * pass the test. If no elements pass the test, an empty array is returned.\n * @signature\n *    filter(predicate)(data)\n * @example\n *    pipe([1, 2, 3], filter(x => x % 2 === 1)) // => [1, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function filter<\n  T extends IterableContainer,\n  Condition extends T[number],\n>(\n  predicate: (value: T[number], index: number, data: T) => value is Condition,\n): (data: T) => FilteredArray<T, Condition>;\nexport function filter<\n  T extends IterableContainer,\n  IsItemIncluded extends boolean,\n>(\n  predicate: (value: T[number], index: number, data: T) => IsItemIncluded,\n): (data: T) => NonRefinedFilteredArray<T, IsItemIncluded>;\n\nexport function filter(...args: ReadonlyArray<unknown>): unknown {\n  return curry(filterImplementation, args, lazyImplementation);\n}\n\nfunction filterImplementation<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, array: ReadonlyArray<T>) => boolean): Array<T> {\n  return data.filter(predicate);\n}\n\nfunction lazyImplementation<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): LazyEvaluator<T> {\n  return (value, index, data) =>\n    predicate(value, index, data)\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n}\n"],"mappings":"mFAmGA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAM,CAAkB,CAC7D,CAEA,SAAS,EAAwB,EAAwB,EAAoF,CAC3I,OAAO,EAAK,OAAO,CAAS,CAC9B,CAEA,SAAS,EAAsB,EAA2F,CACxH,OAAQ,EAAO,EAAO,IACpB,EAAU,EAAO,EAAO,CAAI,EACxB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,EAC1C,CACR"}

package/dist/find-index.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return e.findIndex(t)}exports.findIndex=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){return e.findIndex(t)}exports.findIndex=t;
 //# sourceMappingURL=find-index.cjs.map

package/dist/find-index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"find-index.cjs","names":["curry"],"sources":["../src/find-index.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Returns the index of the first element in an array that satisfies the\n * provided testing function. If no elements satisfy the testing function, -1 is\n * returned.\n *\n * See also the `find` method, which returns the first element that satisfies\n * the testing function (rather than its index).\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return a `true` to indicate a matching element has been found, and a\n * `false` otherwise.\n * @returns The index of the first element in the array that passes the test.\n * Otherwise, -1.\n * @signature\n *    findIndex(data, predicate)\n * @example\n *    findIndex([1, 3, 4, 6], n => n % 2 === 0) // => 2\n * @dataFirst\n * @category Array\n */\nexport function findIndex<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean,\n): number;\n\n/**\n * Returns the index of the first element in an array that satisfies the\n * provided testing function. If no elements satisfy the testing function, -1 is\n * returned.\n *\n * See also the `find` method, which returns the first element that satisfies\n * the testing function (rather than its index).\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return a `true` to indicate a matching element has been found, and a\n * `false` otherwise.\n * @returns The index of the first element in the array that passes the test.\n * Otherwise, -1.\n * @signature\n *    findIndex(predicate)(data)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      findIndex(n => n % 2 === 0)\n *    ); // => 2\n * @dataLast\n * @category Array\n */\nexport function findIndex<T>(\n  predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => number;\n\nexport function findIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findIndexImplementation, args);\n}\n\nfunction findIndexImplementation<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): number {\n  return data.findIndex(predicate);\n}\n"],"mappings":"kGAuDA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAOA,EAAAA,MAAM,EAAyB,EAAK,CAG7C,SAAS,EAA2B,EAAwB,EAAgF,CAC1I,OAAO,EAAK,UAAU,EAAU"}
+{"version":3,"file":"find-index.cjs","names":["curry"],"sources":["../src/find-index.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Returns the index of the first element in an array that satisfies the\n * provided testing function. If no elements satisfy the testing function, -1 is\n * returned.\n *\n * See also the `find` method, which returns the first element that satisfies\n * the testing function (rather than its index).\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return a `true` to indicate a matching element has been found, and a\n * `false` otherwise.\n * @returns The index of the first element in the array that passes the test.\n * Otherwise, -1.\n * @signature\n *    findIndex(data, predicate)\n * @example\n *    findIndex([1, 3, 4, 6], n => n % 2 === 0) // => 2\n * @dataFirst\n * @category Array\n */\nexport function findIndex<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean,\n): number;\n\n/**\n * Returns the index of the first element in an array that satisfies the\n * provided testing function. If no elements satisfy the testing function, -1 is\n * returned.\n *\n * See also the `find` method, which returns the first element that satisfies\n * the testing function (rather than its index).\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return a `true` to indicate a matching element has been found, and a\n * `false` otherwise.\n * @returns The index of the first element in the array that passes the test.\n * Otherwise, -1.\n * @signature\n *    findIndex(predicate)(data)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      findIndex(n => n % 2 === 0)\n *    ); // => 2\n * @dataLast\n * @category Array\n */\nexport function findIndex<T>(\n  predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => number;\n\nexport function findIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findIndexImplementation, args);\n}\n\nfunction findIndexImplementation<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): number {\n  return data.findIndex(predicate);\n}\n"],"mappings":"kGAuDA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAOA,EAAAA,MAAM,EAAyB,CAAI,CAC5C,CAEA,SAAS,EAA2B,EAAwB,EAAgF,CAC1I,OAAO,EAAK,UAAU,CAAS,CACjC"}

package/dist/find-index.js.map

@@ -1 +1 @@
-{"version":3,"file":"find-index.js","names":[],"sources":["../src/find-index.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Returns the index of the first element in an array that satisfies the\n * provided testing function. If no elements satisfy the testing function, -1 is\n * returned.\n *\n * See also the `find` method, which returns the first element that satisfies\n * the testing function (rather than its index).\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return a `true` to indicate a matching element has been found, and a\n * `false` otherwise.\n * @returns The index of the first element in the array that passes the test.\n * Otherwise, -1.\n * @signature\n *    findIndex(data, predicate)\n * @example\n *    findIndex([1, 3, 4, 6], n => n % 2 === 0) // => 2\n * @dataFirst\n * @category Array\n */\nexport function findIndex<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean,\n): number;\n\n/**\n * Returns the index of the first element in an array that satisfies the\n * provided testing function. If no elements satisfy the testing function, -1 is\n * returned.\n *\n * See also the `find` method, which returns the first element that satisfies\n * the testing function (rather than its index).\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return a `true` to indicate a matching element has been found, and a\n * `false` otherwise.\n * @returns The index of the first element in the array that passes the test.\n * Otherwise, -1.\n * @signature\n *    findIndex(predicate)(data)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      findIndex(n => n % 2 === 0)\n *    ); // => 2\n * @dataLast\n * @category Array\n */\nexport function findIndex<T>(\n  predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => number;\n\nexport function findIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findIndexImplementation, args);\n}\n\nfunction findIndexImplementation<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): number {\n  return data.findIndex(predicate);\n}\n"],"mappings":"mCAuDA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EAA2B,EAAwB,EAAgF,CAC1I,OAAO,EAAK,UAAU,EAAU"}
+{"version":3,"file":"find-index.js","names":[],"sources":["../src/find-index.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Returns the index of the first element in an array that satisfies the\n * provided testing function. If no elements satisfy the testing function, -1 is\n * returned.\n *\n * See also the `find` method, which returns the first element that satisfies\n * the testing function (rather than its index).\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return a `true` to indicate a matching element has been found, and a\n * `false` otherwise.\n * @returns The index of the first element in the array that passes the test.\n * Otherwise, -1.\n * @signature\n *    findIndex(data, predicate)\n * @example\n *    findIndex([1, 3, 4, 6], n => n % 2 === 0) // => 2\n * @dataFirst\n * @category Array\n */\nexport function findIndex<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean,\n): number;\n\n/**\n * Returns the index of the first element in an array that satisfies the\n * provided testing function. If no elements satisfy the testing function, -1 is\n * returned.\n *\n * See also the `find` method, which returns the first element that satisfies\n * the testing function (rather than its index).\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return a `true` to indicate a matching element has been found, and a\n * `false` otherwise.\n * @returns The index of the first element in the array that passes the test.\n * Otherwise, -1.\n * @signature\n *    findIndex(predicate)(data)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      findIndex(n => n % 2 === 0)\n *    ); // => 2\n * @dataLast\n * @category Array\n */\nexport function findIndex<T>(\n  predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => number;\n\nexport function findIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findIndexImplementation, args);\n}\n\nfunction findIndexImplementation<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): number {\n  return data.findIndex(predicate);\n}\n"],"mappings":"mCAuDA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,CAAI,CAC5C,CAEA,SAAS,EAA2B,EAAwB,EAAgF,CAC1I,OAAO,EAAK,UAAU,CAAS,CACjC"}

package/dist/find-last-index.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){for(let n=e.length-1;n>=0;n--)if(t(e[n],n,e))return n;return-1}exports.findLastIndex=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){for(let n=e.length-1;n>=0;n--)if(t(e[n],n,e))return n;return-1}exports.findLastIndex=t;
 //# sourceMappingURL=find-last-index.cjs.map

package/dist/find-last-index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"find-last-index.cjs","names":["curry"],"sources":["../src/find-last-index.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Iterates the array in reverse order and returns the index of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, -1 is returned.\n *\n * See also `findLast` which returns the value of last element that satisfies\n * the testing function (rather than its index).\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise.\n * @returns The index of the last (highest-index) element in the array that\n * passes the test. Otherwise -1 if no matching element is found.\n * @signature\n *    findLastIndex(data, predicate)\n * @example\n *    findLastIndex([1, 3, 4, 6], n => n % 2 === 1) // => 1\n * @dataFirst\n * @category Array\n */\nexport function findLastIndex<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): number;\n\n/**\n * Iterates the array in reverse order and returns the index of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, -1 is returned.\n *\n * See also `findLast` which returns the value of last element that satisfies\n * the testing function (rather than its index).\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise.\n * @returns The index of the last (highest-index) element in the array that\n * passes the test. Otherwise -1 if no matching element is found.\n * @signature\n *    findLastIndex(fn)(items)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      findLastIndex(n => n % 2 === 1)\n *    ) // => 1\n * @dataLast\n * @category Array\n */\nexport function findLastIndex<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (array: ReadonlyArray<T>) => number;\n\nexport function findLastIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findLastIndexImplementation, args);\n}\n\nfunction findLastIndexImplementation<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number {\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.findLastIndex` here.\n\n  for (let i = data.length - 1; i >= 0; i--) {\n    if (predicate(data[i]!, i, data)) {\n      return i;\n    }\n  }\n\n  return -1;\n}\n"],"mappings":"kGAuDA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAOA,EAAAA,MAAM,EAA6B,EAAK,CAGjD,SAAS,EAA+B,EAAwB,EAAiF,CAG/I,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,EAAU,EAAK,GAAK,EAAG,EAAK,CAC9B,OAAO,EAIX,MAAO"}
+{"version":3,"file":"find-last-index.cjs","names":["curry"],"sources":["../src/find-last-index.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Iterates the array in reverse order and returns the index of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, -1 is returned.\n *\n * See also `findLast` which returns the value of last element that satisfies\n * the testing function (rather than its index).\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise.\n * @returns The index of the last (highest-index) element in the array that\n * passes the test. Otherwise -1 if no matching element is found.\n * @signature\n *    findLastIndex(data, predicate)\n * @example\n *    findLastIndex([1, 3, 4, 6], n => n % 2 === 1) // => 1\n * @dataFirst\n * @category Array\n */\nexport function findLastIndex<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): number;\n\n/**\n * Iterates the array in reverse order and returns the index of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, -1 is returned.\n *\n * See also `findLast` which returns the value of last element that satisfies\n * the testing function (rather than its index).\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise.\n * @returns The index of the last (highest-index) element in the array that\n * passes the test. Otherwise -1 if no matching element is found.\n * @signature\n *    findLastIndex(fn)(items)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      findLastIndex(n => n % 2 === 1)\n *    ) // => 1\n * @dataLast\n * @category Array\n */\nexport function findLastIndex<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (array: ReadonlyArray<T>) => number;\n\nexport function findLastIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findLastIndexImplementation, args);\n}\n\nfunction findLastIndexImplementation<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number {\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.findLastIndex` here.\n\n  for (let i = data.length - 1; i >= 0; i--) {\n    if (predicate(data[i]!, i, data)) {\n      return i;\n    }\n  }\n\n  return -1;\n}\n"],"mappings":"kGAuDA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAOA,EAAAA,MAAM,EAA6B,CAAI,CAChD,CAEA,SAAS,EAA+B,EAAwB,EAAiF,CAG/I,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,EAAU,EAAK,GAAK,EAAG,CAAI,EAC7B,OAAO,EAIX,MAAO,EACT"}

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

@@ -1 +1 @@
-{"version":3,"file":"find-last-index.js","names":[],"sources":["../src/find-last-index.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Iterates the array in reverse order and returns the index of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, -1 is returned.\n *\n * See also `findLast` which returns the value of last element that satisfies\n * the testing function (rather than its index).\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise.\n * @returns The index of the last (highest-index) element in the array that\n * passes the test. Otherwise -1 if no matching element is found.\n * @signature\n *    findLastIndex(data, predicate)\n * @example\n *    findLastIndex([1, 3, 4, 6], n => n % 2 === 1) // => 1\n * @dataFirst\n * @category Array\n */\nexport function findLastIndex<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): number;\n\n/**\n * Iterates the array in reverse order and returns the index of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, -1 is returned.\n *\n * See also `findLast` which returns the value of last element that satisfies\n * the testing function (rather than its index).\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise.\n * @returns The index of the last (highest-index) element in the array that\n * passes the test. Otherwise -1 if no matching element is found.\n * @signature\n *    findLastIndex(fn)(items)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      findLastIndex(n => n % 2 === 1)\n *    ) // => 1\n * @dataLast\n * @category Array\n */\nexport function findLastIndex<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (array: ReadonlyArray<T>) => number;\n\nexport function findLastIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findLastIndexImplementation, args);\n}\n\nfunction findLastIndexImplementation<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number {\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.findLastIndex` here.\n\n  for (let i = data.length - 1; i >= 0; i--) {\n    if (predicate(data[i]!, i, data)) {\n      return i;\n    }\n  }\n\n  return -1;\n}\n"],"mappings":"mCAuDA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA6B,EAAK,CAGjD,SAAS,EAA+B,EAAwB,EAAiF,CAG/I,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,EAAU,EAAK,GAAK,EAAG,EAAK,CAC9B,OAAO,EAIX,MAAO"}
+{"version":3,"file":"find-last-index.js","names":[],"sources":["../src/find-last-index.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Iterates the array in reverse order and returns the index of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, -1 is returned.\n *\n * See also `findLast` which returns the value of last element that satisfies\n * the testing function (rather than its index).\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise.\n * @returns The index of the last (highest-index) element in the array that\n * passes the test. Otherwise -1 if no matching element is found.\n * @signature\n *    findLastIndex(data, predicate)\n * @example\n *    findLastIndex([1, 3, 4, 6], n => n % 2 === 1) // => 1\n * @dataFirst\n * @category Array\n */\nexport function findLastIndex<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): number;\n\n/**\n * Iterates the array in reverse order and returns the index of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, -1 is returned.\n *\n * See also `findLast` which returns the value of last element that satisfies\n * the testing function (rather than its index).\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise.\n * @returns The index of the last (highest-index) element in the array that\n * passes the test. Otherwise -1 if no matching element is found.\n * @signature\n *    findLastIndex(fn)(items)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      findLastIndex(n => n % 2 === 1)\n *    ) // => 1\n * @dataLast\n * @category Array\n */\nexport function findLastIndex<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (array: ReadonlyArray<T>) => number;\n\nexport function findLastIndex(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findLastIndexImplementation, args);\n}\n\nfunction findLastIndexImplementation<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number {\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.findLastIndex` here.\n\n  for (let i = data.length - 1; i >= 0; i--) {\n    if (predicate(data[i]!, i, data)) {\n      return i;\n    }\n  }\n\n  return -1;\n}\n"],"mappings":"mCAuDA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA6B,CAAI,CAChD,CAEA,SAAS,EAA+B,EAAwB,EAAiF,CAG/I,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,EAAU,EAAK,GAAK,EAAG,CAAI,EAC7B,OAAO,EAIX,MAAO,EACT"}

package/dist/find-last.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){for(let n=e.length-1;n>=0;n--){let r=e[n];if(t(r,n,e))return r}}exports.findLast=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){for(let n=e.length-1;n>=0;n--){let r=e[n];if(t(r,n,e))return r}}exports.findLast=t;
 //# sourceMappingURL=find-last.cjs.map

package/dist/find-last.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"find-last.cjs","names":["curry"],"sources":["../src/find-last.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Iterates the array in reverse order and returns the value of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, undefined is returned.\n *\n * Similar functions:\n * `find` - If you need the first element that satisfies the provided testing function.\n * `findLastIndex` - If you need the index of the found element in the array.\n * `lastIndexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The last (highest-index) element in the array that satisfies the\n * provided testing function; undefined if no matching element is found.\n * @signature\n *    findLast(data, predicate)\n * @example\n *    findLast([1, 3, 4, 6], n => n % 2 === 1) // => 3\n * @dataFirst\n * @category Array\n */\nexport function findLast<T, S extends T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): S | undefined;\nexport function findLast<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): T | undefined;\n\n/**\n * Iterates the array in reverse order and returns the value of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, undefined is returned.\n *\n * Similar functions:\n * `find` - If you need the first element that satisfies the provided testing function.\n * `findLastIndex` - If you need the index of the found element in the array.\n * `lastIndexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The last (highest-index) element in the array that satisfies the\n * provided testing function; undefined if no matching element is found.\n * @signature\n *    findLast(predicate)(data)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      findLast(n => n % 2 === 1)\n *    ) // => 3\n * @dataLast\n * @category Array\n */\nexport function findLast<T, S extends T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): (data: ReadonlyArray<T>) => S | undefined;\nexport function findLast<T = never>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => T | undefined;\n\nexport function findLast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findLastImplementation, args);\n}\n\nfunction findLastImplementation<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined {\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.findLast` here.\n\n  for (let i = data.length - 1; i >= 0; i--) {\n    const item = data[i]!;\n    if (predicate(item, i, data)) {\n      return item;\n    }\n  }\n\n  return undefined;\n}\n"],"mappings":"kGAwEA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,EAAK,CAG5C,SAAS,EAAuC,EAAwB,EAA2F,CAGjK,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IAAK,CACzC,IAAM,EAAO,EAAK,GAClB,GAAI,EAAU,EAAM,EAAG,EAAK,CAC1B,OAAO"}
+{"version":3,"file":"find-last.cjs","names":["curry"],"sources":["../src/find-last.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Iterates the array in reverse order and returns the value of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, undefined is returned.\n *\n * Similar functions:\n * `find` - If you need the first element that satisfies the provided testing function.\n * `findLastIndex` - If you need the index of the found element in the array.\n * `lastIndexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The last (highest-index) element in the array that satisfies the\n * provided testing function; undefined if no matching element is found.\n * @signature\n *    findLast(data, predicate)\n * @example\n *    findLast([1, 3, 4, 6], n => n % 2 === 1) // => 3\n * @dataFirst\n * @category Array\n */\nexport function findLast<T, S extends T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): S | undefined;\nexport function findLast<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): T | undefined;\n\n/**\n * Iterates the array in reverse order and returns the value of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, undefined is returned.\n *\n * Similar functions:\n * `find` - If you need the first element that satisfies the provided testing function.\n * `findLastIndex` - If you need the index of the found element in the array.\n * `lastIndexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The last (highest-index) element in the array that satisfies the\n * provided testing function; undefined if no matching element is found.\n * @signature\n *    findLast(predicate)(data)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      findLast(n => n % 2 === 1)\n *    ) // => 3\n * @dataLast\n * @category Array\n */\nexport function findLast<T, S extends T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): (data: ReadonlyArray<T>) => S | undefined;\nexport function findLast<T = never>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => T | undefined;\n\nexport function findLast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findLastImplementation, args);\n}\n\nfunction findLastImplementation<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined {\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.findLast` here.\n\n  for (let i = data.length - 1; i >= 0; i--) {\n    const item = data[i]!;\n    if (predicate(item, i, data)) {\n      return item;\n    }\n  }\n\n  return undefined;\n}\n"],"mappings":"kGAwEA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,CAAI,CAC3C,CAEA,SAAS,EAAuC,EAAwB,EAA2F,CAGjK,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IAAK,CACzC,IAAM,EAAO,EAAK,GAClB,GAAI,EAAU,EAAM,EAAG,CAAI,EACzB,OAAO,CAEX,CAGF"}

package/dist/find-last.js.map

@@ -1 +1 @@
-{"version":3,"file":"find-last.js","names":[],"sources":["../src/find-last.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Iterates the array in reverse order and returns the value of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, undefined is returned.\n *\n * Similar functions:\n * `find` - If you need the first element that satisfies the provided testing function.\n * `findLastIndex` - If you need the index of the found element in the array.\n * `lastIndexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The last (highest-index) element in the array that satisfies the\n * provided testing function; undefined if no matching element is found.\n * @signature\n *    findLast(data, predicate)\n * @example\n *    findLast([1, 3, 4, 6], n => n % 2 === 1) // => 3\n * @dataFirst\n * @category Array\n */\nexport function findLast<T, S extends T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): S | undefined;\nexport function findLast<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): T | undefined;\n\n/**\n * Iterates the array in reverse order and returns the value of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, undefined is returned.\n *\n * Similar functions:\n * `find` - If you need the first element that satisfies the provided testing function.\n * `findLastIndex` - If you need the index of the found element in the array.\n * `lastIndexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The last (highest-index) element in the array that satisfies the\n * provided testing function; undefined if no matching element is found.\n * @signature\n *    findLast(predicate)(data)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      findLast(n => n % 2 === 1)\n *    ) // => 3\n * @dataLast\n * @category Array\n */\nexport function findLast<T, S extends T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): (data: ReadonlyArray<T>) => S | undefined;\nexport function findLast<T = never>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => T | undefined;\n\nexport function findLast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findLastImplementation, args);\n}\n\nfunction findLastImplementation<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined {\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.findLast` here.\n\n  for (let i = data.length - 1; i >= 0; i--) {\n    const item = data[i]!;\n    if (predicate(item, i, data)) {\n      return item;\n    }\n  }\n\n  return undefined;\n}\n"],"mappings":"mCAwEA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EAAuC,EAAwB,EAA2F,CAGjK,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IAAK,CACzC,IAAM,EAAO,EAAK,GAClB,GAAI,EAAU,EAAM,EAAG,EAAK,CAC1B,OAAO"}
+{"version":3,"file":"find-last.js","names":[],"sources":["../src/find-last.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Iterates the array in reverse order and returns the value of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, undefined is returned.\n *\n * Similar functions:\n * `find` - If you need the first element that satisfies the provided testing function.\n * `findLastIndex` - If you need the index of the found element in the array.\n * `lastIndexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The last (highest-index) element in the array that satisfies the\n * provided testing function; undefined if no matching element is found.\n * @signature\n *    findLast(data, predicate)\n * @example\n *    findLast([1, 3, 4, 6], n => n % 2 === 1) // => 3\n * @dataFirst\n * @category Array\n */\nexport function findLast<T, S extends T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): S | undefined;\nexport function findLast<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): T | undefined;\n\n/**\n * Iterates the array in reverse order and returns the value of the first\n * element that satisfies the provided testing function. If no elements satisfy\n * the testing function, undefined is returned.\n *\n * Similar functions:\n * `find` - If you need the first element that satisfies the provided testing function.\n * `findLastIndex` - If you need the index of the found element in the array.\n * `lastIndexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The last (highest-index) element in the array that satisfies the\n * provided testing function; undefined if no matching element is found.\n * @signature\n *    findLast(predicate)(data)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      findLast(n => n % 2 === 1)\n *    ) // => 3\n * @dataLast\n * @category Array\n */\nexport function findLast<T, S extends T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): (data: ReadonlyArray<T>) => S | undefined;\nexport function findLast<T = never>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => T | undefined;\n\nexport function findLast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findLastImplementation, args);\n}\n\nfunction findLastImplementation<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined {\n  // TODO [>2]: When node 18 reaches end-of-life bump target lib to ES2023+ and use `Array.prototype.findLast` here.\n\n  for (let i = data.length - 1; i >= 0; i--) {\n    const item = data[i]!;\n    if (predicate(item, i, data)) {\n      return item;\n    }\n  }\n\n  return undefined;\n}\n"],"mappings":"mCAwEA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,CAAI,CAC3C,CAEA,SAAS,EAAuC,EAAwB,EAA2F,CAGjK,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IAAK,CACzC,IAAM,EAAO,EAAK,GAClB,GAAI,EAAU,EAAM,EAAG,CAAI,EACzB,OAAO,CAEX,CAGF"}

package/dist/find.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./utility-evaluators-C8koSp9T.cjs`),n=require(`./to-single-BunGuk7o.cjs`);function r(...t){return e.curry(i,t,n.t(a))}function i(e,t){return e.find(t)}function a(e){return(n,r,i)=>e(n,r,i)?{done:!0,hasNext:!0,next:n}:t.t}exports.find=r;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs"),t=require("./utility-evaluators-BGM19SpK.cjs"),n=require("./to-single-BOkjnmkm.cjs");function r(...t){return e.curry(i,t,n.t(a))}function i(e,t){return e.find(t)}function a(e){return(n,r,i)=>e(n,r,i)?{done:!0,hasNext:!0,next:n}:t.t}exports.find=r;
 //# sourceMappingURL=find.cjs.map

package/dist/find.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"find.cjs","names":["curry","toSingle","SKIP_ITEM"],"sources":["../src/find.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { toSingle } from './internal/to-single';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns the first element in the provided array that satisfies the provided\n * testing function. If no values satisfy the testing function, `undefined` is\n * returned.\n *\n * Similar functions:\n * `findLast` - If you need the last element that satisfies the provided testing function.\n * `findIndex` - If you need the index of the found element in the array.\n * `indexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The first element in the array that satisfies the provided testing\n * function. Otherwise, `undefined` is returned.\n * @signature\n *    find(data, predicate)\n * @example\n *    find([1, 3, 4, 6], n => n % 2 === 0) // => 4\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function find<T, S extends T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): S | undefined;\nexport function find<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): T | undefined;\n\n/**\n * Returns the first element in the provided array that satisfies the provided\n * testing function. If no values satisfy the testing function, `undefined` is\n * returned.\n *\n * Similar functions:\n * `findLast` - If you need the last element that satisfies the provided testing function.\n * `findIndex` - If you need the index of the found element in the array.\n * `indexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The first element in the array that satisfies the provided testing\n * function. Otherwise, `undefined` is returned.\n * @signature\n *    find(predicate)(data)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      find(n => n % 2 === 0)\n *    ) // => 4\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function find<T, S extends T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): (data: ReadonlyArray<T>) => S | undefined;\nexport function find<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => T | undefined;\n\nexport function find(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findImplementation, args, toSingle(lazyImplementation));\n}\n\nfunction findImplementation<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined {\n  return data.find(predicate);\n}\n\nfunction lazyImplementation<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): LazyEvaluator<T, S> {\n  return (value, index, data) =>\n    predicate(value, index, data)\n      ? { done: true, hasNext: true, next: value }\n      : SKIP_ITEM;\n}\n"],"mappings":"uLA6EA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,EAAMC,EAAAA,EAAS,EAAmB,CAAC,CAGtE,SAAS,EAAmC,EAAwB,EAA2F,CAC7J,OAAO,EAAK,KAAK,EAAU,CAG7B,SAAS,EAAmC,EAAiG,CAC3I,OAAQ,EAAO,EAAO,IACpB,EAAU,EAAO,EAAO,EAAK,CACzB,CAAE,KAAM,GAAM,QAAS,GAAM,KAAM,EAAO,CAC1CC,EAAAA"}
+{"version":3,"file":"find.cjs","names":["curry","toSingle","SKIP_ITEM"],"sources":["../src/find.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { toSingle } from './internal/to-single';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns the first element in the provided array that satisfies the provided\n * testing function. If no values satisfy the testing function, `undefined` is\n * returned.\n *\n * Similar functions:\n * `findLast` - If you need the last element that satisfies the provided testing function.\n * `findIndex` - If you need the index of the found element in the array.\n * `indexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The first element in the array that satisfies the provided testing\n * function. Otherwise, `undefined` is returned.\n * @signature\n *    find(data, predicate)\n * @example\n *    find([1, 3, 4, 6], n => n % 2 === 0) // => 4\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function find<T, S extends T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): S | undefined;\nexport function find<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): T | undefined;\n\n/**\n * Returns the first element in the provided array that satisfies the provided\n * testing function. If no values satisfy the testing function, `undefined` is\n * returned.\n *\n * Similar functions:\n * `findLast` - If you need the last element that satisfies the provided testing function.\n * `findIndex` - If you need the index of the found element in the array.\n * `indexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The first element in the array that satisfies the provided testing\n * function. Otherwise, `undefined` is returned.\n * @signature\n *    find(predicate)(data)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      find(n => n % 2 === 0)\n *    ) // => 4\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function find<T, S extends T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): (data: ReadonlyArray<T>) => S | undefined;\nexport function find<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => T | undefined;\n\nexport function find(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findImplementation, args, toSingle(lazyImplementation));\n}\n\nfunction findImplementation<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined {\n  return data.find(predicate);\n}\n\nfunction lazyImplementation<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): LazyEvaluator<T, S> {\n  return (value, index, data) =>\n    predicate(value, index, data)\n      ? { done: true, hasNext: true, next: value }\n      : SKIP_ITEM;\n}\n"],"mappings":"uLA6EA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,EAAMC,EAAAA,EAAS,CAAkB,CAAC,CACrE,CAEA,SAAS,EAAmC,EAAwB,EAA2F,CAC7J,OAAO,EAAK,KAAK,CAAS,CAC5B,CAEA,SAAS,EAAmC,EAAiG,CAC3I,OAAQ,EAAO,EAAO,IACpB,EAAU,EAAO,EAAO,CAAI,EACxB,CAAE,KAAM,GAAM,QAAS,GAAM,KAAM,CAAM,EACzCC,EAAAA,CACR"}

package/dist/find.js

@@ -1,2 +1,2 @@
-import{curry as e}from"./curry.js";import{t}from"./utility-evaluators-ZAaUtL2Z.js";import{t as n}from"./to-single-XEXXW73e.js";function r(...t){return e(i,t,n(a))}function i(e,t){return e.find(t)}function a(e){return(n,r,i)=>e(n,r,i)?{done:!0,hasNext:!0,next:n}:t}export{r as find};
+import{curry as e}from"./curry.js";import{t}from"./utility-evaluators-DDW55xeL.js";import{t as n}from"./to-single-D6t2BxVq.js";function r(...t){return e(i,t,n(a))}function i(e,t){return e.find(t)}function a(e){return(n,r,i)=>e(n,r,i)?{done:!0,hasNext:!0,next:n}:t}export{r as find};
 //# sourceMappingURL=find.js.map

package/dist/find.js.map

@@ -1 +1 @@
-{"version":3,"file":"find.js","names":[],"sources":["../src/find.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { toSingle } from './internal/to-single';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns the first element in the provided array that satisfies the provided\n * testing function. If no values satisfy the testing function, `undefined` is\n * returned.\n *\n * Similar functions:\n * `findLast` - If you need the last element that satisfies the provided testing function.\n * `findIndex` - If you need the index of the found element in the array.\n * `indexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The first element in the array that satisfies the provided testing\n * function. Otherwise, `undefined` is returned.\n * @signature\n *    find(data, predicate)\n * @example\n *    find([1, 3, 4, 6], n => n % 2 === 0) // => 4\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function find<T, S extends T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): S | undefined;\nexport function find<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): T | undefined;\n\n/**\n * Returns the first element in the provided array that satisfies the provided\n * testing function. If no values satisfy the testing function, `undefined` is\n * returned.\n *\n * Similar functions:\n * `findLast` - If you need the last element that satisfies the provided testing function.\n * `findIndex` - If you need the index of the found element in the array.\n * `indexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The first element in the array that satisfies the provided testing\n * function. Otherwise, `undefined` is returned.\n * @signature\n *    find(predicate)(data)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      find(n => n % 2 === 0)\n *    ) // => 4\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function find<T, S extends T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): (data: ReadonlyArray<T>) => S | undefined;\nexport function find<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => T | undefined;\n\nexport function find(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findImplementation, args, toSingle(lazyImplementation));\n}\n\nfunction findImplementation<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined {\n  return data.find(predicate);\n}\n\nfunction lazyImplementation<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): LazyEvaluator<T, S> {\n  return (value, index, data) =>\n    predicate(value, index, data)\n      ? { done: true, hasNext: true, next: value }\n      : SKIP_ITEM;\n}\n"],"mappings":"+HA6EA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAM,EAAS,EAAmB,CAAC,CAGtE,SAAS,EAAmC,EAAwB,EAA2F,CAC7J,OAAO,EAAK,KAAK,EAAU,CAG7B,SAAS,EAAmC,EAAiG,CAC3I,OAAQ,EAAO,EAAO,IACpB,EAAU,EAAO,EAAO,EAAK,CACzB,CAAE,KAAM,GAAM,QAAS,GAAM,KAAM,EAAO,CAC1C"}
+{"version":3,"file":"find.js","names":[],"sources":["../src/find.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { toSingle } from './internal/to-single';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns the first element in the provided array that satisfies the provided\n * testing function. If no values satisfy the testing function, `undefined` is\n * returned.\n *\n * Similar functions:\n * `findLast` - If you need the last element that satisfies the provided testing function.\n * `findIndex` - If you need the index of the found element in the array.\n * `indexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param data - The items to search in.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The first element in the array that satisfies the provided testing\n * function. Otherwise, `undefined` is returned.\n * @signature\n *    find(data, predicate)\n * @example\n *    find([1, 3, 4, 6], n => n % 2 === 0) // => 4\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function find<T, S extends T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): S | undefined;\nexport function find<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): T | undefined;\n\n/**\n * Returns the first element in the provided array that satisfies the provided\n * testing function. If no values satisfy the testing function, `undefined` is\n * returned.\n *\n * Similar functions:\n * `findLast` - If you need the last element that satisfies the provided testing function.\n * `findIndex` - If you need the index of the found element in the array.\n * `indexOf` - If you need to find the index of a value.\n * `includes` - If you need to find if a value exists in an array.\n * `some` - If you need to find if any element satisfies the provided testing function.\n * `filter` - If you need to find all elements that satisfy the provided testing function.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to indicate a matching element has been found, and\n * `false` otherwise. A type-predicate can also be used to narrow the result.\n * @returns The first element in the array that satisfies the provided testing\n * function. Otherwise, `undefined` is returned.\n * @signature\n *    find(predicate)(data)\n * @example\n *    pipe(\n *      [1, 3, 4, 6],\n *      find(n => n % 2 === 0)\n *    ) // => 4\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function find<T, S extends T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): (data: ReadonlyArray<T>) => S | undefined;\nexport function find<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => T | undefined;\n\nexport function find(...args: ReadonlyArray<unknown>): unknown {\n  return curry(findImplementation, args, toSingle(lazyImplementation));\n}\n\nfunction findImplementation<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined {\n  return data.find(predicate);\n}\n\nfunction lazyImplementation<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): LazyEvaluator<T, S> {\n  return (value, index, data) =>\n    predicate(value, index, data)\n      ? { done: true, hasNext: true, next: value }\n      : SKIP_ITEM;\n}\n"],"mappings":"+HA6EA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAM,EAAS,CAAkB,CAAC,CACrE,CAEA,SAAS,EAAmC,EAAwB,EAA2F,CAC7J,OAAO,EAAK,KAAK,CAAS,CAC5B,CAEA,SAAS,EAAmC,EAAiG,CAC3I,OAAQ,EAAO,EAAO,IACpB,EAAU,EAAO,EAAO,CAAI,EACxB,CAAE,KAAM,GAAM,QAAS,GAAM,KAAM,CAAM,EACzC,CACR"}

package/dist/first-by.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry-order-rules-DsJSy3gX.cjs`),t=require(`./has-at-least.cjs`);function n(...t){return e.t(r,t)}function r(e,n){if(!t.hasAtLeast(e,2))return e[0];let[r]=e,[,...i]=e;for(let e of i)n(e,r)<0&&(r=e);return r}exports.firstBy=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry-order-rules-CacOTzfW.cjs"),t=require("./has-at-least.cjs");function n(...t){return e.t(r,t)}function r(e,n){if(!t.hasAtLeast(e,2))return e[0];let[r]=e,[,...i]=e;for(let e of i)n(e,r)<0&&(r=e);return r}exports.firstBy=n;
 //# sourceMappingURL=first-by.cjs.map

package/dist/first-by.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"first-by.cjs","names":["curryOrderRules","hasAtLeast"],"sources":["../src/first-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 { hasAtLeast } from './has-at-least';\nimport { curryOrderRules } from './internal/curry-order-rules';\n\ntype FirstBy<T extends IterableContainer>\n  = | T[number]\n    | (T extends readonly [unknown, ...(ReadonlyArray<unknown>)]\n      ? never\n      : T extends readonly [...(ReadonlyArray<unknown>), unknown]\n        ? never\n        : undefined);\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `first(sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\n * @param rules - 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.\n * @returns The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   firstBy(...rules)(data);\n * @example\n *   const max = pipe([1,2,3], firstBy([identity(), \"desc\"])); // => 3;\n *   const min = pipe([1,2,3], firstBy(identity())); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = pipe(data, firstBy([(item) => item.a.length, \"desc\"])); // => { a: \"aaa\" };\n *   const minBy = pipe(data, firstBy((item) => item.a.length)); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = pipe(data, firstBy(prop('type'), [prop('size'), 'desc'])); // => {type: \"cat\", size: 2}\n * @dataLast\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (data: T) => FirstBy<T>;\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `first(sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\n * @param data - An array of items.\n * @param rules - 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.\n * @returns The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   firstBy(data, ...rules);\n * @example\n *   const max = firstBy([1,2,3], [identity(), \"desc\"]); // => 3;\n *   const min = firstBy([1,2,3], identity()); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = firstBy(data, [(item) => item.a.length, \"desc\"]); // => { a: \"aaa\" };\n *   const minBy = firstBy(data, (item) => item.a.length); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = firstBy(data, prop('type'), [prop('size'), 'desc']); // => {type: \"cat\", size: 2}\n * @dataFirst\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  data: T,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): FirstBy<T>;\n\nexport function firstBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRules(firstByImplementation, args);\n}\n\nfunction firstByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n): T | undefined {\n  if (!hasAtLeast(data, 2)) {\n    // If we have 0 or 1 item we simply return the trivial result.\n    return data[0];\n  }\n\n  let [currentFirst] = data;\n\n  // Remove the first item, we won't compare it with itself.\n  const [, ...rest] = data;\n  for (const item of rest) {\n    if (compareFn(item, currentFirst) < 0) {\n      // item comes before currentFirst in the order.\n      currentFirst = item;\n    }\n  }\n\n  return currentFirst;\n}\n"],"mappings":"uJAyEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,EAAgB,EAAuB,EAAK,CAGrD,SAAS,EACP,EACA,EACe,CACf,GAAI,CAACC,EAAAA,WAAW,EAAM,EAAE,CAEtB,OAAO,EAAK,GAGd,GAAI,CAAC,GAAgB,EAGf,EAAG,GAAG,GAAQ,EACpB,IAAK,IAAM,KAAQ,EACb,EAAU,EAAM,EAAa,CAAG,IAElC,EAAe,GAInB,OAAO"}
+{"version":3,"file":"first-by.cjs","names":["curryOrderRules","hasAtLeast"],"sources":["../src/first-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 { hasAtLeast } from './has-at-least';\nimport { curryOrderRules } from './internal/curry-order-rules';\n\ntype FirstBy<T extends IterableContainer>\n  = | T[number]\n    | (T extends readonly [unknown, ...(ReadonlyArray<unknown>)]\n      ? never\n      : T extends readonly [...(ReadonlyArray<unknown>), unknown]\n        ? never\n        : undefined);\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `first(sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\n * @param rules - 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.\n * @returns The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   firstBy(...rules)(data);\n * @example\n *   const max = pipe([1,2,3], firstBy([identity(), \"desc\"])); // => 3;\n *   const min = pipe([1,2,3], firstBy(identity())); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = pipe(data, firstBy([(item) => item.a.length, \"desc\"])); // => { a: \"aaa\" };\n *   const minBy = pipe(data, firstBy((item) => item.a.length)); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = pipe(data, firstBy(prop('type'), [prop('size'), 'desc'])); // => {type: \"cat\", size: 2}\n * @dataLast\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (data: T) => FirstBy<T>;\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `first(sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\n * @param data - An array of items.\n * @param rules - 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.\n * @returns The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   firstBy(data, ...rules);\n * @example\n *   const max = firstBy([1,2,3], [identity(), \"desc\"]); // => 3;\n *   const min = firstBy([1,2,3], identity()); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = firstBy(data, [(item) => item.a.length, \"desc\"]); // => { a: \"aaa\" };\n *   const minBy = firstBy(data, (item) => item.a.length); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = firstBy(data, prop('type'), [prop('size'), 'desc']); // => {type: \"cat\", size: 2}\n * @dataFirst\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  data: T,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): FirstBy<T>;\n\nexport function firstBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRules(firstByImplementation, args);\n}\n\nfunction firstByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n): T | undefined {\n  if (!hasAtLeast(data, 2)) {\n    // If we have 0 or 1 item we simply return the trivial result.\n    return data[0];\n  }\n\n  let [currentFirst] = data;\n\n  // Remove the first item, we won't compare it with itself.\n  const [, ...rest] = data;\n  for (const item of rest) {\n    if (compareFn(item, currentFirst) < 0) {\n      // item comes before currentFirst in the order.\n      currentFirst = item;\n    }\n  }\n\n  return currentFirst;\n}\n"],"mappings":"uJAyEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,EAAgB,EAAuB,CAAI,CACpD,CAEA,SAAS,EACP,EACA,EACe,CACf,GAAI,CAACC,EAAAA,WAAW,EAAM,CAAC,EAErB,OAAO,EAAK,GAGd,GAAI,CAAC,GAAgB,EAGf,EAAG,GAAG,GAAQ,EACpB,IAAK,IAAM,KAAQ,EACb,EAAU,EAAM,CAAY,EAAI,IAElC,EAAe,GAInB,OAAO,CACT"}

package/dist/first-by.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-order-rules-BLyCSMdZ.js";import{hasAtLeast as t}from"./has-at-least.js";function n(...t){return e(r,t)}function r(e,n){if(!t(e,2))return e[0];let[r]=e,[,...i]=e;for(let e of i)n(e,r)<0&&(r=e);return r}export{n as firstBy};
+import{t as e}from"./curry-order-rules-Dage-BeC.js";import{hasAtLeast as t}from"./has-at-least.js";function n(...t){return e(r,t)}function r(e,n){if(!t(e,2))return e[0];let[r]=e,[,...i]=e;for(let e of i)n(e,r)<0&&(r=e);return r}export{n as firstBy};
 //# sourceMappingURL=first-by.js.map

package/dist/first-by.js.map

@@ -1 +1 @@
-{"version":3,"file":"first-by.js","names":[],"sources":["../src/first-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 { hasAtLeast } from './has-at-least';\nimport { curryOrderRules } from './internal/curry-order-rules';\n\ntype FirstBy<T extends IterableContainer>\n  = | T[number]\n    | (T extends readonly [unknown, ...(ReadonlyArray<unknown>)]\n      ? never\n      : T extends readonly [...(ReadonlyArray<unknown>), unknown]\n        ? never\n        : undefined);\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `first(sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\n * @param rules - 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.\n * @returns The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   firstBy(...rules)(data);\n * @example\n *   const max = pipe([1,2,3], firstBy([identity(), \"desc\"])); // => 3;\n *   const min = pipe([1,2,3], firstBy(identity())); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = pipe(data, firstBy([(item) => item.a.length, \"desc\"])); // => { a: \"aaa\" };\n *   const minBy = pipe(data, firstBy((item) => item.a.length)); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = pipe(data, firstBy(prop('type'), [prop('size'), 'desc'])); // => {type: \"cat\", size: 2}\n * @dataLast\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (data: T) => FirstBy<T>;\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `first(sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\n * @param data - An array of items.\n * @param rules - 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.\n * @returns The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   firstBy(data, ...rules);\n * @example\n *   const max = firstBy([1,2,3], [identity(), \"desc\"]); // => 3;\n *   const min = firstBy([1,2,3], identity()); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = firstBy(data, [(item) => item.a.length, \"desc\"]); // => { a: \"aaa\" };\n *   const minBy = firstBy(data, (item) => item.a.length); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = firstBy(data, prop('type'), [prop('size'), 'desc']); // => {type: \"cat\", size: 2}\n * @dataFirst\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  data: T,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): FirstBy<T>;\n\nexport function firstBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRules(firstByImplementation, args);\n}\n\nfunction firstByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n): T | undefined {\n  if (!hasAtLeast(data, 2)) {\n    // If we have 0 or 1 item we simply return the trivial result.\n    return data[0];\n  }\n\n  let [currentFirst] = data;\n\n  // Remove the first item, we won't compare it with itself.\n  const [, ...rest] = data;\n  for (const item of rest) {\n    if (compareFn(item, currentFirst) < 0) {\n      // item comes before currentFirst in the order.\n      currentFirst = item;\n    }\n  }\n\n  return currentFirst;\n}\n"],"mappings":"mGAyEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAgB,EAAuB,EAAK,CAGrD,SAAS,EACP,EACA,EACe,CACf,GAAI,CAAC,EAAW,EAAM,EAAE,CAEtB,OAAO,EAAK,GAGd,GAAI,CAAC,GAAgB,EAGf,EAAG,GAAG,GAAQ,EACpB,IAAK,IAAM,KAAQ,EACb,EAAU,EAAM,EAAa,CAAG,IAElC,EAAe,GAInB,OAAO"}
+{"version":3,"file":"first-by.js","names":[],"sources":["../src/first-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 { hasAtLeast } from './has-at-least';\nimport { curryOrderRules } from './internal/curry-order-rules';\n\ntype FirstBy<T extends IterableContainer>\n  = | T[number]\n    | (T extends readonly [unknown, ...(ReadonlyArray<unknown>)]\n      ? never\n      : T extends readonly [...(ReadonlyArray<unknown>), unknown]\n        ? never\n        : undefined);\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `first(sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\n * @param rules - 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.\n * @returns The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   firstBy(...rules)(data);\n * @example\n *   const max = pipe([1,2,3], firstBy([identity(), \"desc\"])); // => 3;\n *   const min = pipe([1,2,3], firstBy(identity())); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = pipe(data, firstBy([(item) => item.a.length, \"desc\"])); // => { a: \"aaa\" };\n *   const minBy = pipe(data, firstBy((item) => item.a.length)); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = pipe(data, firstBy(prop('type'), [prop('size'), 'desc'])); // => {type: \"cat\", size: 2}\n * @dataLast\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (data: T) => FirstBy<T>;\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `first(sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\n * @param data - An array of items.\n * @param rules - 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.\n * @returns The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   firstBy(data, ...rules);\n * @example\n *   const max = firstBy([1,2,3], [identity(), \"desc\"]); // => 3;\n *   const min = firstBy([1,2,3], identity()); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = firstBy(data, [(item) => item.a.length, \"desc\"]); // => { a: \"aaa\" };\n *   const minBy = firstBy(data, (item) => item.a.length); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = firstBy(data, prop('type'), [prop('size'), 'desc']); // => {type: \"cat\", size: 2}\n * @dataFirst\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  data: T,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): FirstBy<T>;\n\nexport function firstBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRules(firstByImplementation, args);\n}\n\nfunction firstByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n): T | undefined {\n  if (!hasAtLeast(data, 2)) {\n    // If we have 0 or 1 item we simply return the trivial result.\n    return data[0];\n  }\n\n  let [currentFirst] = data;\n\n  // Remove the first item, we won't compare it with itself.\n  const [, ...rest] = data;\n  for (const item of rest) {\n    if (compareFn(item, currentFirst) < 0) {\n      // item comes before currentFirst in the order.\n      currentFirst = item;\n    }\n  }\n\n  return currentFirst;\n}\n"],"mappings":"mGAyEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAgB,EAAuB,CAAI,CACpD,CAEA,SAAS,EACP,EACA,EACe,CACf,GAAI,CAAC,EAAW,EAAM,CAAC,EAErB,OAAO,EAAK,GAGd,GAAI,CAAC,GAAgB,EAGf,EAAG,GAAG,GAAQ,EACpB,IAAK,IAAM,KAAQ,EACb,EAAU,EAAM,CAAY,EAAI,IAElC,EAAe,GAInB,OAAO,CACT"}

package/dist/first.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./to-single-BunGuk7o.cjs`);function n(...n){return e.curry(r,n,t.t(i))}const r=([e])=>e,i=()=>a;function a(e){return{hasNext:!0,next:e,done:!0}}exports.first=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs"),t=require("./to-single-BOkjnmkm.cjs");function n(...n){return e.curry(r,n,t.t(i))}const r=([e])=>e,i=()=>a;function a(e){return{hasNext:!0,next:e,done:!0}}exports.first=n;
 //# sourceMappingURL=first.cjs.map

package/dist/first.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"first.cjs","names":["curry","toSingle"],"sources":["../src/first.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { toSingle } from './internal/to-single';\n\ntype First<T extends IterableContainer> = T extends []\n  ? undefined\n  : T extends readonly [unknown, ...Array<unknown>]\n    ? T[0]\n    : T extends readonly [...infer Pre, infer Last]\n      ? Last | Pre[0]\n      : T[0] | undefined;\n\n/**\n * Gets the first element of `array`.\n *\n * @param data - The array.\n * @returns The first element of the array.\n * @signature\n *    first(array)\n * @example\n *    first([1, 2, 3]) // => 1\n *    first([]) // => undefined\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function first<T extends IterableContainer>(data: T): First<T>;\n\n/**\n * Gets the first element of `array`.\n *\n * @returns The first element of the array.\n * @signature\n *    first()(array)\n * @example\n *    pipe(\n *      [1, 2, 4, 8, 16],\n *      filter(x => x > 3),\n *      first(),\n *      x => x + 1\n *    ); // => 5\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function first(): <T extends IterableContainer>(data: T) => First<T>;\n\nexport function first(...args: ReadonlyArray<unknown>): unknown {\n  return curry(firstImplementation, args, toSingle(lazyImplementation));\n}\n\nconst firstImplementation = <T>([item]: ReadonlyArray<T>): T | undefined => item;\n\nconst lazyImplementation = (): LazyEvaluator => firstLazy;\n\nfunction firstLazy<T>(value: T) {\n  return ({ hasNext: true, next: value, done: true }) as const;\n}\n"],"mappings":"wIAgDA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAM,EAAqB,EAAMC,EAAAA,EAAS,EAAmB,CAAC,CAGvE,MAAM,GAA0B,CAAC,KAA2C,EAEtE,MAA0C,EAEhD,SAAS,EAAa,EAAU,CAC9B,MAAQ,CAAE,QAAS,GAAM,KAAM,EAAO,KAAM,GAAM"}
+{"version":3,"file":"first.cjs","names":["curry","toSingle"],"sources":["../src/first.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { toSingle } from './internal/to-single';\n\ntype First<T extends IterableContainer> = T extends []\n  ? undefined\n  : T extends readonly [unknown, ...Array<unknown>]\n    ? T[0]\n    : T extends readonly [...infer Pre, infer Last]\n      ? Last | Pre[0]\n      : T[0] | undefined;\n\n/**\n * Gets the first element of `array`.\n *\n * @param data - The array.\n * @returns The first element of the array.\n * @signature\n *    first(array)\n * @example\n *    first([1, 2, 3]) // => 1\n *    first([]) // => undefined\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function first<T extends IterableContainer>(data: T): First<T>;\n\n/**\n * Gets the first element of `array`.\n *\n * @returns The first element of the array.\n * @signature\n *    first()(array)\n * @example\n *    pipe(\n *      [1, 2, 4, 8, 16],\n *      filter(x => x > 3),\n *      first(),\n *      x => x + 1\n *    ); // => 5\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function first(): <T extends IterableContainer>(data: T) => First<T>;\n\nexport function first(...args: ReadonlyArray<unknown>): unknown {\n  return curry(firstImplementation, args, toSingle(lazyImplementation));\n}\n\nconst firstImplementation = <T>([item]: ReadonlyArray<T>): T | undefined => item;\n\nconst lazyImplementation = (): LazyEvaluator => firstLazy;\n\nfunction firstLazy<T>(value: T) {\n  return ({ hasNext: true, next: value, done: true }) as const;\n}\n"],"mappings":"wIAgDA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAM,EAAqB,EAAMC,EAAAA,EAAS,CAAkB,CAAC,CACtE,CAEA,MAAM,GAA0B,CAAC,KAA2C,EAEtE,MAA0C,EAEhD,SAAS,EAAa,EAAU,CAC9B,MAAQ,CAAE,QAAS,GAAM,KAAM,EAAO,KAAM,EAAK,CACnD"}

package/dist/first.js

@@ -1,2 +1,2 @@
-import{curry as e}from"./curry.js";import{t}from"./to-single-XEXXW73e.js";function n(...n){return e(r,n,t(i))}const r=([e])=>e,i=()=>a;function a(e){return{hasNext:!0,next:e,done:!0}}export{n as first};
+import{curry as e}from"./curry.js";import{t}from"./to-single-D6t2BxVq.js";function n(...n){return e(r,n,t(i))}const r=([e])=>e,i=()=>a;function a(e){return{hasNext:!0,next:e,done:!0}}export{n as first};
 //# sourceMappingURL=first.js.map

package/dist/first.js.map

@@ -1 +1 @@
-{"version":3,"file":"first.js","names":[],"sources":["../src/first.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { toSingle } from './internal/to-single';\n\ntype First<T extends IterableContainer> = T extends []\n  ? undefined\n  : T extends readonly [unknown, ...Array<unknown>]\n    ? T[0]\n    : T extends readonly [...infer Pre, infer Last]\n      ? Last | Pre[0]\n      : T[0] | undefined;\n\n/**\n * Gets the first element of `array`.\n *\n * @param data - The array.\n * @returns The first element of the array.\n * @signature\n *    first(array)\n * @example\n *    first([1, 2, 3]) // => 1\n *    first([]) // => undefined\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function first<T extends IterableContainer>(data: T): First<T>;\n\n/**\n * Gets the first element of `array`.\n *\n * @returns The first element of the array.\n * @signature\n *    first()(array)\n * @example\n *    pipe(\n *      [1, 2, 4, 8, 16],\n *      filter(x => x > 3),\n *      first(),\n *      x => x + 1\n *    ); // => 5\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function first(): <T extends IterableContainer>(data: T) => First<T>;\n\nexport function first(...args: ReadonlyArray<unknown>): unknown {\n  return curry(firstImplementation, args, toSingle(lazyImplementation));\n}\n\nconst firstImplementation = <T>([item]: ReadonlyArray<T>): T | undefined => item;\n\nconst lazyImplementation = (): LazyEvaluator => firstLazy;\n\nfunction firstLazy<T>(value: T) {\n  return ({ hasNext: true, next: value, done: true }) as const;\n}\n"],"mappings":"0EAgDA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAM,EAAS,EAAmB,CAAC,CAGvE,MAAM,GAA0B,CAAC,KAA2C,EAEtE,MAA0C,EAEhD,SAAS,EAAa,EAAU,CAC9B,MAAQ,CAAE,QAAS,GAAM,KAAM,EAAO,KAAM,GAAM"}
+{"version":3,"file":"first.js","names":[],"sources":["../src/first.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { toSingle } from './internal/to-single';\n\ntype First<T extends IterableContainer> = T extends []\n  ? undefined\n  : T extends readonly [unknown, ...Array<unknown>]\n    ? T[0]\n    : T extends readonly [...infer Pre, infer Last]\n      ? Last | Pre[0]\n      : T[0] | undefined;\n\n/**\n * Gets the first element of `array`.\n *\n * @param data - The array.\n * @returns The first element of the array.\n * @signature\n *    first(array)\n * @example\n *    first([1, 2, 3]) // => 1\n *    first([]) // => undefined\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function first<T extends IterableContainer>(data: T): First<T>;\n\n/**\n * Gets the first element of `array`.\n *\n * @returns The first element of the array.\n * @signature\n *    first()(array)\n * @example\n *    pipe(\n *      [1, 2, 4, 8, 16],\n *      filter(x => x > 3),\n *      first(),\n *      x => x + 1\n *    ); // => 5\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function first(): <T extends IterableContainer>(data: T) => First<T>;\n\nexport function first(...args: ReadonlyArray<unknown>): unknown {\n  return curry(firstImplementation, args, toSingle(lazyImplementation));\n}\n\nconst firstImplementation = <T>([item]: ReadonlyArray<T>): T | undefined => item;\n\nconst lazyImplementation = (): LazyEvaluator => firstLazy;\n\nfunction firstLazy<T>(value: T) {\n  return ({ hasNext: true, next: value, done: true }) as const;\n}\n"],"mappings":"0EAgDA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAM,EAAS,CAAkB,CAAC,CACtE,CAEA,MAAM,GAA0B,CAAC,KAA2C,EAEtE,MAA0C,EAEhD,SAAS,EAAa,EAAU,CAC9B,MAAQ,CAAE,QAAS,GAAM,KAAM,EAAO,KAAM,EAAK,CACnD"}

package/dist/flat-map.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t,r)}function n(e,t){return e.flatMap(t)}function r(e){return(t,n,r)=>{let i=e(t,n,r);return Array.isArray(i)?{done:!1,hasNext:!0,hasMany:!0,next:i}:{done:!1,hasNext:!0,next:i}}}exports.flatMap=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t,r)}function n(e,t){return e.flatMap(t)}function r(e){return(t,n,r)=>{let i=e(t,n,r);return Array.isArray(i)?{done:!1,hasNext:!0,hasMany:!0,next:i}:{done:!1,hasNext:!0,next:i}}}exports.flatMap=t;
 //# sourceMappingURL=flat-map.cjs.map

package/dist/flat-map.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"flat-map.cjs","names":["curry"],"sources":["../src/flat-map.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param data - The items to map and flatten.\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    flatMap(data, callbackfn)\n * @example\n *    flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U,\n): Array<U>;\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    flatMap(callbackfn)(data)\n * @example\n *    pipe([1, 2, 3], flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U,\n): (data: ReadonlyArray<T>) => Array<U>;\n\nexport function flatMap(...args: ReadonlyArray<unknown>): unknown {\n  return curry(flatMapImplementation, args, lazyImplementation);\n}\n\nfunction flatMapImplementation<T, U>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): Array<U> {\n  return data.flatMap(callbackfn);\n}\n\nfunction lazyImplementation<T, K>(callbackfn: (\n  input: T,\n  index: number,\n  data: ReadonlyArray<T>,\n) => K | ReadonlyArray<K>): LazyEvaluator<T, K> {\n  return (value, index, data) => {\n    const next = callbackfn(value, index, data);\n    return Array.isArray(next)\n      ? { done: false, hasNext: true, hasMany: true, next }\n      : { done: false, hasNext: true, next };\n  };\n}\n"],"mappings":"kGAqDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAM,EAAmB,CAG/D,SAAS,EAA4B,EAAwB,EAAiG,CAC5J,OAAO,EAAK,QAAQ,EAAW,CAGjC,SAAS,EAAyB,EAIc,CAC9C,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAO,EAAW,EAAO,EAAO,EAAK,CAC3C,OAAO,MAAM,QAAQ,EAAK,CACtB,CAAE,KAAM,GAAO,QAAS,GAAM,QAAS,GAAM,OAAM,CACnD,CAAE,KAAM,GAAO,QAAS,GAAM,OAAM"}
+{"version":3,"file":"flat-map.cjs","names":["curry"],"sources":["../src/flat-map.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param data - The items to map and flatten.\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    flatMap(data, callbackfn)\n * @example\n *    flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U,\n): Array<U>;\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    flatMap(callbackfn)(data)\n * @example\n *    pipe([1, 2, 3], flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U,\n): (data: ReadonlyArray<T>) => Array<U>;\n\nexport function flatMap(...args: ReadonlyArray<unknown>): unknown {\n  return curry(flatMapImplementation, args, lazyImplementation);\n}\n\nfunction flatMapImplementation<T, U>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): Array<U> {\n  return data.flatMap(callbackfn);\n}\n\nfunction lazyImplementation<T, K>(callbackfn: (\n  input: T,\n  index: number,\n  data: ReadonlyArray<T>,\n) => K | ReadonlyArray<K>): LazyEvaluator<T, K> {\n  return (value, index, data) => {\n    const next = callbackfn(value, index, data);\n    return Array.isArray(next)\n      ? { done: false, hasNext: true, hasMany: true, next }\n      : { done: false, hasNext: true, next };\n  };\n}\n"],"mappings":"kGAqDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAM,CAAkB,CAC9D,CAEA,SAAS,EAA4B,EAAwB,EAAiG,CAC5J,OAAO,EAAK,QAAQ,CAAU,CAChC,CAEA,SAAS,EAAyB,EAIc,CAC9C,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAO,EAAW,EAAO,EAAO,CAAI,EAC1C,OAAO,MAAM,QAAQ,CAAI,EACrB,CAAE,KAAM,GAAO,QAAS,GAAM,QAAS,GAAM,MAAK,EAClD,CAAE,KAAM,GAAO,QAAS,GAAM,MAAK,CACzC,CACF"}

package/dist/flat-map.js.map

@@ -1 +1 @@
-{"version":3,"file":"flat-map.js","names":[],"sources":["../src/flat-map.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param data - The items to map and flatten.\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    flatMap(data, callbackfn)\n * @example\n *    flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U,\n): Array<U>;\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    flatMap(callbackfn)(data)\n * @example\n *    pipe([1, 2, 3], flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U,\n): (data: ReadonlyArray<T>) => Array<U>;\n\nexport function flatMap(...args: ReadonlyArray<unknown>): unknown {\n  return curry(flatMapImplementation, args, lazyImplementation);\n}\n\nfunction flatMapImplementation<T, U>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): Array<U> {\n  return data.flatMap(callbackfn);\n}\n\nfunction lazyImplementation<T, K>(callbackfn: (\n  input: T,\n  index: number,\n  data: ReadonlyArray<T>,\n) => K | ReadonlyArray<K>): LazyEvaluator<T, K> {\n  return (value, index, data) => {\n    const next = callbackfn(value, index, data);\n    return Array.isArray(next)\n      ? { done: false, hasNext: true, hasMany: true, next }\n      : { done: false, hasNext: true, next };\n  };\n}\n"],"mappings":"mCAqDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAM,EAAmB,CAG/D,SAAS,EAA4B,EAAwB,EAAiG,CAC5J,OAAO,EAAK,QAAQ,EAAW,CAGjC,SAAS,EAAyB,EAIc,CAC9C,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAO,EAAW,EAAO,EAAO,EAAK,CAC3C,OAAO,MAAM,QAAQ,EAAK,CACtB,CAAE,KAAM,GAAO,QAAS,GAAM,QAAS,GAAM,OAAM,CACnD,CAAE,KAAM,GAAO,QAAS,GAAM,OAAM"}
+{"version":3,"file":"flat-map.js","names":[],"sources":["../src/flat-map.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param data - The items to map and flatten.\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    flatMap(data, callbackfn)\n * @example\n *    flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U,\n): Array<U>;\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    flatMap(callbackfn)(data)\n * @example\n *    pipe([1, 2, 3], flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U,\n): (data: ReadonlyArray<T>) => Array<U>;\n\nexport function flatMap(...args: ReadonlyArray<unknown>): unknown {\n  return curry(flatMapImplementation, args, lazyImplementation);\n}\n\nfunction flatMapImplementation<T, U>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): Array<U> {\n  return data.flatMap(callbackfn);\n}\n\nfunction lazyImplementation<T, K>(callbackfn: (\n  input: T,\n  index: number,\n  data: ReadonlyArray<T>,\n) => K | ReadonlyArray<K>): LazyEvaluator<T, K> {\n  return (value, index, data) => {\n    const next = callbackfn(value, index, data);\n    return Array.isArray(next)\n      ? { done: false, hasNext: true, hasMany: true, next }\n      : { done: false, hasNext: true, next };\n  };\n}\n"],"mappings":"mCAqDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAM,CAAkB,CAC9D,CAEA,SAAS,EAA4B,EAAwB,EAAiG,CAC5J,OAAO,EAAK,QAAQ,CAAU,CAChC,CAEA,SAAS,EAAyB,EAIc,CAC9C,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAO,EAAW,EAAO,EAAO,CAAI,EAC1C,OAAO,MAAM,QAAQ,CAAI,EACrB,CAAE,KAAM,GAAO,QAAS,GAAM,QAAS,GAAM,MAAK,EAClD,CAAE,KAAM,GAAO,QAAS,GAAM,MAAK,CACzC,CACF"}

package/dist/flat.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./lazy-data-last-impl-B05ZpguF.cjs`),t=require(`./utility-evaluators-C8koSp9T.cjs`);function n(t,n){return typeof t==`object`?r(t,n):e.t(r,t===void 0?[]:[t],i)}function r(e,t){return t===void 0?e.flat():e.flat(t)}function i(e){return e===void 0||e===1?a:e<=0?t.r:t=>Array.isArray(t)?{next:t.flat(e-1),hasNext:!0,hasMany:!0,done:!1}:{next:t,hasNext:!0,done:!1}}function a(e){return Array.isArray(e)?{next:e,hasNext:!0,hasMany:!0,done:!1}:{next:e,hasNext:!0,done:!1}}exports.flat=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./lazy-data-last-impl-Dd5zjCfU.cjs"),t=require("./utility-evaluators-BGM19SpK.cjs");function n(t,n){return typeof t==`object`?r(t,n):e.t(r,t===void 0?[]:[t],i)}function r(e,t){return t===void 0?e.flat():e.flat(t)}function i(e){return e===void 0||e===1?a:e<=0?t.r:t=>Array.isArray(t)?{next:t.flat(e-1),hasNext:!0,hasMany:!0,done:!1}:{next:t,hasNext:!0,done:!1}}function a(e){return Array.isArray(e)?{next:e,hasNext:!0,hasMany:!0,done:!1}:{next:e,hasNext:!0,done:!1}}exports.flat=n;
 //# sourceMappingURL=flat.cjs.map

package/dist/flat.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"flat.cjs","names":["lazyDataLastImpl","lazyIdentityEvaluator"],"sources":["../src/flat.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { LazyResult } from './internal/types/lazy-result';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\nimport { lazyIdentityEvaluator } from './internal/utility-evaluators';\n\ntype FlatArray<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = Depth extends Iteration['length']\n  ? // Stopping condition for the recursion when the array is a tuple.\n  T\n  : T extends readonly []\n    ? // Trivial result when the array is empty.\n      []\n    : T extends readonly [infer Item, ...infer Rest]\n      ? // Tuples could be special-cased by \"iterating\" over each item\n        // separately so that we maintain more information from the input type,\n        // instead of putting all values in a union.\n        [\n          ...(Item extends IterableContainer\n            ? // If the item itself is an array we continue going deeper\n            FlatArray<Item, Depth, [...Iteration, unknown]>\n            : // But if it isn't we add it to the output tuple\n              [Item]),\n          // And we merge this with the result from the rest of the tuple.\n          ...FlatArray<Rest, Depth, Iteration>,\n        ]\n      : // For simple arrays we compute the item type, and wrap it with an\n    // array.\n      Array<FlatSimpleArrayItems<T, Depth, Iteration>>;\n\n// This type is based on the built-in type for `Array.prototype.flat` from the\n// ES2019 Array typescript library, but we improved it to handle any depth\n// (avoiding the fixed `20` in the built-in type).\n// @see https://github.com/microsoft/TypeScript/blob/main/src/lib/es2019.array.d.ts#L1-L5\ntype FlatSimpleArrayItems<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n  IsDone extends boolean = false,\n> = {\n  done: T;\n  recur: T extends ReadonlyArray<infer InnerArr>\n    ? FlatSimpleArrayItems<\n      InnerArr,\n      Depth,\n      [...Iteration, unknown],\n      // This trick allows us to continue 1 iteration more than the depth,\n      // which is required to flatten the array up to depth.\n      Iteration['length'] extends Depth ? true : false\n    >\n    : T;\n}[IsDone extends true ? 'done' : 'recur'];\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param data - The items to flatten.\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1. Non literal values (those typed as\n * `number`cannot be used. `Infinity`, `Number.POSITIVE_INFINITY` and\n * `Number.MAX_VALUE` are all typed as `number` and can't be used either. For\n * \"unlimited\" depth use a literal value that would exceed your expected\n * practical maximum nesting level.\n * @signature\n *   flat(data)\n *   flat(data, depth)\n * @example\n *   flat([[1, 2], [3, 4], [5], [[6]]]); // => [1, 2, 3, 4, 5, [6]]\n *   flat([[[1]], [[2]]], 2); // => [1, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flat<T extends IterableContainer, Depth extends number = 1>(\n  data: T,\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): FlatArray<T, Depth>;\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1.\n * @signature\n *   flat()(data)\n *   flat(depth)(data)\n * @example\n *   pipe([[1, 2], [3, 4], [5], [[6]]], flat()); // => [1, 2, 3, 4, 5, [6]]\n *   pipe([[[1]], [[2]]], flat(2)); // => [1, 2]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flat<Depth extends number = 1>(\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;\n\nexport function flat(\n  dataOrDepth?: IterableContainer | number,\n  depth?: number,\n): unknown {\n  if (typeof dataOrDepth === 'object') {\n    return flatImplementation(dataOrDepth, depth);\n  }\n\n  return lazyDataLastImpl(\n    flatImplementation,\n    dataOrDepth === undefined ? [] : [dataOrDepth],\n    lazyImplementation,\n  );\n}\n\nfunction flatImplementation(data: IterableContainer, depth?: number): IterableContainer {\n  return depth === undefined ? data.flat() : data.flat(depth);\n}\n\nfunction lazyImplementation(depth?: number): LazyEvaluator {\n  if (depth === undefined || depth === 1) {\n    return lazyShallow;\n  }\n\n  if (depth <= 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  return (value) =>\n    Array.isArray(value)\n      ? {\n          next: value.flat(depth - 1),\n          hasNext: true,\n          hasMany: true,\n          done: false,\n        }\n      : { next: value, hasNext: true, done: false }; ;\n}\n\n// This function is pulled out so that we don't generate a new arrow function\n// each time. Because it doesn't need to run with recursion it could be pulled\n// out from the lazyImplementation and be reused for all invocations.\nfunction lazyShallow<T>(value: T): LazyResult<T> {\n  return Array.isArray(value)\n    ? { next: value, hasNext: true, hasMany: true, done: false }\n    : { next: value, hasNext: true, done: false };\n}\n"],"mappings":"wKAyGA,SAAgB,EACd,EACA,EACS,CAKT,OAJI,OAAO,GAAgB,SAClB,EAAmB,EAAa,EAAM,CAGxCA,EAAAA,EACL,EACA,IAAgB,IAAA,GAAY,EAAE,CAAG,CAAC,EAAY,CAC9C,EACD,CAGH,SAAS,EAAmB,EAAyB,EAAmC,CACtF,OAAO,IAAU,IAAA,GAAY,EAAK,MAAM,CAAG,EAAK,KAAK,EAAM,CAG7D,SAAS,EAAmB,EAA+B,CASzD,OARI,IAAU,IAAA,IAAa,IAAU,EAC5B,EAGL,GAAS,EACJC,EAAAA,EAGD,GACN,MAAM,QAAQ,EAAM,CAChB,CACE,KAAM,EAAM,KAAK,EAAQ,EAAE,CAC3B,QAAS,GACT,QAAS,GACT,KAAM,GACP,CACD,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,GAAO,CAMnD,SAAS,EAAe,EAAyB,CAC/C,OAAO,MAAM,QAAQ,EAAM,CACvB,CAAE,KAAM,EAAO,QAAS,GAAM,QAAS,GAAM,KAAM,GAAO,CAC1D,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,GAAO"}
+{"version":3,"file":"flat.cjs","names":["lazyDataLastImpl","lazyIdentityEvaluator"],"sources":["../src/flat.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { LazyResult } from './internal/types/lazy-result';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\nimport { lazyIdentityEvaluator } from './internal/utility-evaluators';\n\ntype FlatArray<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = Depth extends Iteration['length']\n  ? // Stopping condition for the recursion when the array is a tuple.\n  T\n  : T extends readonly []\n    ? // Trivial result when the array is empty.\n      []\n    : T extends readonly [infer Item, ...infer Rest]\n      ? // Tuples could be special-cased by \"iterating\" over each item\n        // separately so that we maintain more information from the input type,\n        // instead of putting all values in a union.\n        [\n          ...(Item extends IterableContainer\n            ? // If the item itself is an array we continue going deeper\n            FlatArray<Item, Depth, [...Iteration, unknown]>\n            : // But if it isn't we add it to the output tuple\n              [Item]),\n          // And we merge this with the result from the rest of the tuple.\n          ...FlatArray<Rest, Depth, Iteration>,\n        ]\n      : // For simple arrays we compute the item type, and wrap it with an\n    // array.\n      Array<FlatSimpleArrayItems<T, Depth, Iteration>>;\n\n// This type is based on the built-in type for `Array.prototype.flat` from the\n// ES2019 Array typescript library, but we improved it to handle any depth\n// (avoiding the fixed `20` in the built-in type).\n// @see https://github.com/microsoft/TypeScript/blob/main/src/lib/es2019.array.d.ts#L1-L5\ntype FlatSimpleArrayItems<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n  IsDone extends boolean = false,\n> = {\n  done: T;\n  recur: T extends ReadonlyArray<infer InnerArr>\n    ? FlatSimpleArrayItems<\n      InnerArr,\n      Depth,\n      [...Iteration, unknown],\n      // This trick allows us to continue 1 iteration more than the depth,\n      // which is required to flatten the array up to depth.\n      Iteration['length'] extends Depth ? true : false\n    >\n    : T;\n}[IsDone extends true ? 'done' : 'recur'];\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param data - The items to flatten.\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1. Non literal values (those typed as\n * `number`cannot be used. `Infinity`, `Number.POSITIVE_INFINITY` and\n * `Number.MAX_VALUE` are all typed as `number` and can't be used either. For\n * \"unlimited\" depth use a literal value that would exceed your expected\n * practical maximum nesting level.\n * @signature\n *   flat(data)\n *   flat(data, depth)\n * @example\n *   flat([[1, 2], [3, 4], [5], [[6]]]); // => [1, 2, 3, 4, 5, [6]]\n *   flat([[[1]], [[2]]], 2); // => [1, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flat<T extends IterableContainer, Depth extends number = 1>(\n  data: T,\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): FlatArray<T, Depth>;\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1.\n * @signature\n *   flat()(data)\n *   flat(depth)(data)\n * @example\n *   pipe([[1, 2], [3, 4], [5], [[6]]], flat()); // => [1, 2, 3, 4, 5, [6]]\n *   pipe([[[1]], [[2]]], flat(2)); // => [1, 2]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flat<Depth extends number = 1>(\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;\n\nexport function flat(\n  dataOrDepth?: IterableContainer | number,\n  depth?: number,\n): unknown {\n  if (typeof dataOrDepth === 'object') {\n    return flatImplementation(dataOrDepth, depth);\n  }\n\n  return lazyDataLastImpl(\n    flatImplementation,\n    dataOrDepth === undefined ? [] : [dataOrDepth],\n    lazyImplementation,\n  );\n}\n\nfunction flatImplementation(data: IterableContainer, depth?: number): IterableContainer {\n  return depth === undefined ? data.flat() : data.flat(depth);\n}\n\nfunction lazyImplementation(depth?: number): LazyEvaluator {\n  if (depth === undefined || depth === 1) {\n    return lazyShallow;\n  }\n\n  if (depth <= 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  return (value) =>\n    Array.isArray(value)\n      ? {\n          next: value.flat(depth - 1),\n          hasNext: true,\n          hasMany: true,\n          done: false,\n        }\n      : { next: value, hasNext: true, done: false }; ;\n}\n\n// This function is pulled out so that we don't generate a new arrow function\n// each time. Because it doesn't need to run with recursion it could be pulled\n// out from the lazyImplementation and be reused for all invocations.\nfunction lazyShallow<T>(value: T): LazyResult<T> {\n  return Array.isArray(value)\n    ? { next: value, hasNext: true, hasMany: true, done: false }\n    : { next: value, hasNext: true, done: false };\n}\n"],"mappings":"wKAyGA,SAAgB,EACd,EACA,EACS,CAKT,OAJI,OAAO,GAAgB,SAClB,EAAmB,EAAa,CAAK,EAGvCA,EAAAA,EACL,EACA,IAAgB,IAAA,GAAY,CAAC,EAAI,CAAC,CAAW,EAC7C,CACF,CACF,CAEA,SAAS,EAAmB,EAAyB,EAAmC,CACtF,OAAO,IAAU,IAAA,GAAY,EAAK,KAAK,EAAI,EAAK,KAAK,CAAK,CAC5D,CAEA,SAAS,EAAmB,EAA+B,CASzD,OARI,IAAU,IAAA,IAAa,IAAU,EAC5B,EAGL,GAAS,EACJC,EAAAA,EAGD,GACN,MAAM,QAAQ,CAAK,EACf,CACE,KAAM,EAAM,KAAK,EAAQ,CAAC,EAC1B,QAAS,GACT,QAAS,GACT,KAAM,EACR,EACA,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,EAAM,CAClD,CAKA,SAAS,EAAe,EAAyB,CAC/C,OAAO,MAAM,QAAQ,CAAK,EACtB,CAAE,KAAM,EAAO,QAAS,GAAM,QAAS,GAAM,KAAM,EAAM,EACzD,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,EAAM,CAChD"}

package/dist/flat.js

@@ -1,2 +1,2 @@
-import{t as e}from"./lazy-data-last-impl-Vt_M0l7X.js";import{r as t}from"./utility-evaluators-ZAaUtL2Z.js";function n(t,n){return typeof t==`object`?r(t,n):e(r,t===void 0?[]:[t],i)}function r(e,t){return t===void 0?e.flat():e.flat(t)}function i(e){return e===void 0||e===1?a:e<=0?t:t=>Array.isArray(t)?{next:t.flat(e-1),hasNext:!0,hasMany:!0,done:!1}:{next:t,hasNext:!0,done:!1}}function a(e){return Array.isArray(e)?{next:e,hasNext:!0,hasMany:!0,done:!1}:{next:e,hasNext:!0,done:!1}}export{n as flat};
+import{t as e}from"./lazy-data-last-impl--3B10z3s.js";import{r as t}from"./utility-evaluators-DDW55xeL.js";function n(t,n){return typeof t==`object`?r(t,n):e(r,t===void 0?[]:[t],i)}function r(e,t){return t===void 0?e.flat():e.flat(t)}function i(e){return e===void 0||e===1?a:e<=0?t:t=>Array.isArray(t)?{next:t.flat(e-1),hasNext:!0,hasMany:!0,done:!1}:{next:t,hasNext:!0,done:!1}}function a(e){return Array.isArray(e)?{next:e,hasNext:!0,hasMany:!0,done:!1}:{next:e,hasNext:!0,done:!1}}export{n as flat};
 //# sourceMappingURL=flat.js.map

package/dist/flat.js.map

@@ -1 +1 @@
-{"version":3,"file":"flat.js","names":[],"sources":["../src/flat.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { LazyResult } from './internal/types/lazy-result';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\nimport { lazyIdentityEvaluator } from './internal/utility-evaluators';\n\ntype FlatArray<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = Depth extends Iteration['length']\n  ? // Stopping condition for the recursion when the array is a tuple.\n  T\n  : T extends readonly []\n    ? // Trivial result when the array is empty.\n      []\n    : T extends readonly [infer Item, ...infer Rest]\n      ? // Tuples could be special-cased by \"iterating\" over each item\n        // separately so that we maintain more information from the input type,\n        // instead of putting all values in a union.\n        [\n          ...(Item extends IterableContainer\n            ? // If the item itself is an array we continue going deeper\n            FlatArray<Item, Depth, [...Iteration, unknown]>\n            : // But if it isn't we add it to the output tuple\n              [Item]),\n          // And we merge this with the result from the rest of the tuple.\n          ...FlatArray<Rest, Depth, Iteration>,\n        ]\n      : // For simple arrays we compute the item type, and wrap it with an\n    // array.\n      Array<FlatSimpleArrayItems<T, Depth, Iteration>>;\n\n// This type is based on the built-in type for `Array.prototype.flat` from the\n// ES2019 Array typescript library, but we improved it to handle any depth\n// (avoiding the fixed `20` in the built-in type).\n// @see https://github.com/microsoft/TypeScript/blob/main/src/lib/es2019.array.d.ts#L1-L5\ntype FlatSimpleArrayItems<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n  IsDone extends boolean = false,\n> = {\n  done: T;\n  recur: T extends ReadonlyArray<infer InnerArr>\n    ? FlatSimpleArrayItems<\n      InnerArr,\n      Depth,\n      [...Iteration, unknown],\n      // This trick allows us to continue 1 iteration more than the depth,\n      // which is required to flatten the array up to depth.\n      Iteration['length'] extends Depth ? true : false\n    >\n    : T;\n}[IsDone extends true ? 'done' : 'recur'];\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param data - The items to flatten.\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1. Non literal values (those typed as\n * `number`cannot be used. `Infinity`, `Number.POSITIVE_INFINITY` and\n * `Number.MAX_VALUE` are all typed as `number` and can't be used either. For\n * \"unlimited\" depth use a literal value that would exceed your expected\n * practical maximum nesting level.\n * @signature\n *   flat(data)\n *   flat(data, depth)\n * @example\n *   flat([[1, 2], [3, 4], [5], [[6]]]); // => [1, 2, 3, 4, 5, [6]]\n *   flat([[[1]], [[2]]], 2); // => [1, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flat<T extends IterableContainer, Depth extends number = 1>(\n  data: T,\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): FlatArray<T, Depth>;\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1.\n * @signature\n *   flat()(data)\n *   flat(depth)(data)\n * @example\n *   pipe([[1, 2], [3, 4], [5], [[6]]], flat()); // => [1, 2, 3, 4, 5, [6]]\n *   pipe([[[1]], [[2]]], flat(2)); // => [1, 2]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flat<Depth extends number = 1>(\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;\n\nexport function flat(\n  dataOrDepth?: IterableContainer | number,\n  depth?: number,\n): unknown {\n  if (typeof dataOrDepth === 'object') {\n    return flatImplementation(dataOrDepth, depth);\n  }\n\n  return lazyDataLastImpl(\n    flatImplementation,\n    dataOrDepth === undefined ? [] : [dataOrDepth],\n    lazyImplementation,\n  );\n}\n\nfunction flatImplementation(data: IterableContainer, depth?: number): IterableContainer {\n  return depth === undefined ? data.flat() : data.flat(depth);\n}\n\nfunction lazyImplementation(depth?: number): LazyEvaluator {\n  if (depth === undefined || depth === 1) {\n    return lazyShallow;\n  }\n\n  if (depth <= 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  return (value) =>\n    Array.isArray(value)\n      ? {\n          next: value.flat(depth - 1),\n          hasNext: true,\n          hasMany: true,\n          done: false,\n        }\n      : { next: value, hasNext: true, done: false }; ;\n}\n\n// This function is pulled out so that we don't generate a new arrow function\n// each time. Because it doesn't need to run with recursion it could be pulled\n// out from the lazyImplementation and be reused for all invocations.\nfunction lazyShallow<T>(value: T): LazyResult<T> {\n  return Array.isArray(value)\n    ? { next: value, hasNext: true, hasMany: true, done: false }\n    : { next: value, hasNext: true, done: false };\n}\n"],"mappings":"2GAyGA,SAAgB,EACd,EACA,EACS,CAKT,OAJI,OAAO,GAAgB,SAClB,EAAmB,EAAa,EAAM,CAGxC,EACL,EACA,IAAgB,IAAA,GAAY,EAAE,CAAG,CAAC,EAAY,CAC9C,EACD,CAGH,SAAS,EAAmB,EAAyB,EAAmC,CACtF,OAAO,IAAU,IAAA,GAAY,EAAK,MAAM,CAAG,EAAK,KAAK,EAAM,CAG7D,SAAS,EAAmB,EAA+B,CASzD,OARI,IAAU,IAAA,IAAa,IAAU,EAC5B,EAGL,GAAS,EACJ,EAGD,GACN,MAAM,QAAQ,EAAM,CAChB,CACE,KAAM,EAAM,KAAK,EAAQ,EAAE,CAC3B,QAAS,GACT,QAAS,GACT,KAAM,GACP,CACD,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,GAAO,CAMnD,SAAS,EAAe,EAAyB,CAC/C,OAAO,MAAM,QAAQ,EAAM,CACvB,CAAE,KAAM,EAAO,QAAS,GAAM,QAAS,GAAM,KAAM,GAAO,CAC1D,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,GAAO"}
+{"version":3,"file":"flat.js","names":[],"sources":["../src/flat.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { LazyResult } from './internal/types/lazy-result';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\nimport { lazyIdentityEvaluator } from './internal/utility-evaluators';\n\ntype FlatArray<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = Depth extends Iteration['length']\n  ? // Stopping condition for the recursion when the array is a tuple.\n  T\n  : T extends readonly []\n    ? // Trivial result when the array is empty.\n      []\n    : T extends readonly [infer Item, ...infer Rest]\n      ? // Tuples could be special-cased by \"iterating\" over each item\n        // separately so that we maintain more information from the input type,\n        // instead of putting all values in a union.\n        [\n          ...(Item extends IterableContainer\n            ? // If the item itself is an array we continue going deeper\n            FlatArray<Item, Depth, [...Iteration, unknown]>\n            : // But if it isn't we add it to the output tuple\n              [Item]),\n          // And we merge this with the result from the rest of the tuple.\n          ...FlatArray<Rest, Depth, Iteration>,\n        ]\n      : // For simple arrays we compute the item type, and wrap it with an\n    // array.\n      Array<FlatSimpleArrayItems<T, Depth, Iteration>>;\n\n// This type is based on the built-in type for `Array.prototype.flat` from the\n// ES2019 Array typescript library, but we improved it to handle any depth\n// (avoiding the fixed `20` in the built-in type).\n// @see https://github.com/microsoft/TypeScript/blob/main/src/lib/es2019.array.d.ts#L1-L5\ntype FlatSimpleArrayItems<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n  IsDone extends boolean = false,\n> = {\n  done: T;\n  recur: T extends ReadonlyArray<infer InnerArr>\n    ? FlatSimpleArrayItems<\n      InnerArr,\n      Depth,\n      [...Iteration, unknown],\n      // This trick allows us to continue 1 iteration more than the depth,\n      // which is required to flatten the array up to depth.\n      Iteration['length'] extends Depth ? true : false\n    >\n    : T;\n}[IsDone extends true ? 'done' : 'recur'];\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param data - The items to flatten.\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1. Non literal values (those typed as\n * `number`cannot be used. `Infinity`, `Number.POSITIVE_INFINITY` and\n * `Number.MAX_VALUE` are all typed as `number` and can't be used either. For\n * \"unlimited\" depth use a literal value that would exceed your expected\n * practical maximum nesting level.\n * @signature\n *   flat(data)\n *   flat(data, depth)\n * @example\n *   flat([[1, 2], [3, 4], [5], [[6]]]); // => [1, 2, 3, 4, 5, [6]]\n *   flat([[[1]], [[2]]], 2); // => [1, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flat<T extends IterableContainer, Depth extends number = 1>(\n  data: T,\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): FlatArray<T, Depth>;\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1.\n * @signature\n *   flat()(data)\n *   flat(depth)(data)\n * @example\n *   pipe([[1, 2], [3, 4], [5], [[6]]], flat()); // => [1, 2, 3, 4, 5, [6]]\n *   pipe([[[1]], [[2]]], flat(2)); // => [1, 2]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flat<Depth extends number = 1>(\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;\n\nexport function flat(\n  dataOrDepth?: IterableContainer | number,\n  depth?: number,\n): unknown {\n  if (typeof dataOrDepth === 'object') {\n    return flatImplementation(dataOrDepth, depth);\n  }\n\n  return lazyDataLastImpl(\n    flatImplementation,\n    dataOrDepth === undefined ? [] : [dataOrDepth],\n    lazyImplementation,\n  );\n}\n\nfunction flatImplementation(data: IterableContainer, depth?: number): IterableContainer {\n  return depth === undefined ? data.flat() : data.flat(depth);\n}\n\nfunction lazyImplementation(depth?: number): LazyEvaluator {\n  if (depth === undefined || depth === 1) {\n    return lazyShallow;\n  }\n\n  if (depth <= 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  return (value) =>\n    Array.isArray(value)\n      ? {\n          next: value.flat(depth - 1),\n          hasNext: true,\n          hasMany: true,\n          done: false,\n        }\n      : { next: value, hasNext: true, done: false }; ;\n}\n\n// This function is pulled out so that we don't generate a new arrow function\n// each time. Because it doesn't need to run with recursion it could be pulled\n// out from the lazyImplementation and be reused for all invocations.\nfunction lazyShallow<T>(value: T): LazyResult<T> {\n  return Array.isArray(value)\n    ? { next: value, hasNext: true, hasMany: true, done: false }\n    : { next: value, hasNext: true, done: false };\n}\n"],"mappings":"2GAyGA,SAAgB,EACd,EACA,EACS,CAKT,OAJI,OAAO,GAAgB,SAClB,EAAmB,EAAa,CAAK,EAGvC,EACL,EACA,IAAgB,IAAA,GAAY,CAAC,EAAI,CAAC,CAAW,EAC7C,CACF,CACF,CAEA,SAAS,EAAmB,EAAyB,EAAmC,CACtF,OAAO,IAAU,IAAA,GAAY,EAAK,KAAK,EAAI,EAAK,KAAK,CAAK,CAC5D,CAEA,SAAS,EAAmB,EAA+B,CASzD,OARI,IAAU,IAAA,IAAa,IAAU,EAC5B,EAGL,GAAS,EACJ,EAGD,GACN,MAAM,QAAQ,CAAK,EACf,CACE,KAAM,EAAM,KAAK,EAAQ,CAAC,EAC1B,QAAS,GACT,QAAS,GACT,KAAM,EACR,EACA,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,EAAM,CAClD,CAKA,SAAS,EAAe,EAAyB,CAC/C,OAAO,MAAM,QAAQ,CAAK,EACtB,CAAE,KAAM,EAAO,QAAS,GAAM,QAAS,GAAM,KAAM,EAAM,EACzD,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,EAAM,CAChD"}

package/dist/floor.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./with-precision-DVi9325n.cjs`);function n(...n){return e.curry(t.t(Math.floor),n)}exports.floor=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs"),t=require("./with-precision-Dy5W6bdk.cjs");function n(...n){return e.curry(t.t(Math.floor),n)}exports.floor=n;
 //# sourceMappingURL=floor.cjs.map

package/dist/floor.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"floor.cjs","names":["curry","withPrecision"],"sources":["../src/floor.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round down.\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    floor(value, precision);\n * @example\n *    floor(123.9876, 3) // => 123.987\n *    floor(483.22243, 1) // => 483.2\n *    floor(8541, -1) // => 8540\n *    floor(456789, -3) // => 456000\n * @dataFirst\n * @category Number\n */\nexport function floor(value: number, precision: number): number;\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    floor(precision)(value);\n * @example\n *    floor(3)(123.9876) // => 123.987\n *    floor(1)(483.22243) // => 483.2\n *    floor(-1)(8541) // => 8540\n *    floor(-3)(456789) // => 456000\n * @dataLast\n * @category Number\n */\nexport function floor(precision: number): (value: number) => number;\n\nexport function floor(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.floor), args);\n}\n"],"mappings":"6IAwCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAMC,EAAAA,EAAc,KAAK,MAAM,CAAE,EAAK"}
+{"version":3,"file":"floor.cjs","names":["curry","withPrecision"],"sources":["../src/floor.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round down.\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    floor(value, precision);\n * @example\n *    floor(123.9876, 3) // => 123.987\n *    floor(483.22243, 1) // => 483.2\n *    floor(8541, -1) // => 8540\n *    floor(456789, -3) // => 456000\n * @dataFirst\n * @category Number\n */\nexport function floor(value: number, precision: number): number;\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    floor(precision)(value);\n * @example\n *    floor(3)(123.9876) // => 123.987\n *    floor(1)(483.22243) // => 483.2\n *    floor(-1)(8541) // => 8540\n *    floor(-3)(456789) // => 456000\n * @dataLast\n * @category Number\n */\nexport function floor(precision: number): (value: number) => number;\n\nexport function floor(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.floor), args);\n}\n"],"mappings":"6IAwCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAMC,EAAAA,EAAc,KAAK,KAAK,EAAG,CAAI,CAC9C"}

package/dist/floor.js

@@ -1,2 +1,2 @@
-import{curry as e}from"./curry.js";import{t}from"./with-precision-CgRuf7Wl.js";function n(...n){return e(t(Math.floor),n)}export{n as floor};
+import{curry as e}from"./curry.js";import{t}from"./with-precision-D-84B_By.js";function n(...n){return e(t(Math.floor),n)}export{n as floor};
 //# sourceMappingURL=floor.js.map

package/dist/floor.js.map

@@ -1 +1 @@
-{"version":3,"file":"floor.js","names":[],"sources":["../src/floor.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round down.\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    floor(value, precision);\n * @example\n *    floor(123.9876, 3) // => 123.987\n *    floor(483.22243, 1) // => 483.2\n *    floor(8541, -1) // => 8540\n *    floor(456789, -3) // => 456000\n * @dataFirst\n * @category Number\n */\nexport function floor(value: number, precision: number): number;\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    floor(precision)(value);\n * @example\n *    floor(3)(123.9876) // => 123.987\n *    floor(1)(483.22243) // => 483.2\n *    floor(-1)(8541) // => 8540\n *    floor(-3)(456789) // => 456000\n * @dataLast\n * @category Number\n */\nexport function floor(precision: number): (value: number) => number;\n\nexport function floor(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.floor), args);\n}\n"],"mappings":"+EAwCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAc,KAAK,MAAM,CAAE,EAAK"}
+{"version":3,"file":"floor.js","names":[],"sources":["../src/floor.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round down.\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    floor(value, precision);\n * @example\n *    floor(123.9876, 3) // => 123.987\n *    floor(483.22243, 1) // => 483.2\n *    floor(8541, -1) // => 8540\n *    floor(456789, -3) // => 456000\n * @dataFirst\n * @category Number\n */\nexport function floor(value: number, precision: number): number;\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    floor(precision)(value);\n * @example\n *    floor(3)(123.9876) // => 123.987\n *    floor(1)(483.22243) // => 483.2\n *    floor(-1)(8541) // => 8540\n *    floor(-3)(456789) // => 456000\n * @dataLast\n * @category Number\n */\nexport function floor(precision: number): (value: number) => number;\n\nexport function floor(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.floor), args);\n}\n"],"mappings":"+EAwCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAc,KAAK,KAAK,EAAG,CAAI,CAC9C"}

package/dist/for-each-obj.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){for(let[n,r]of Object.entries(e))t(r,n,e);return e}exports.forEachObj=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){for(let[n,r]of Object.entries(e))t(r,n,e);return e}exports.forEachObj=t;
 //# sourceMappingURL=for-each-obj.cjs.map

package/dist/for-each-obj.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"for-each-obj.cjs","names":["curry"],"sources":["../src/for-each-obj.ts"],"sourcesContent":["import type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport { curry } from './curry';\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param data - The object who'se entries would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    forEachObj(object, fn)\n * @example\n *    forEachObj({a: 1}, (val, key, obj) => {\n *      console.log(`${key}: ${val}`)\n *    }) // \"a: 1\"\n * @dataFirst\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  data: T,\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): void;\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original object (the ref itself, not a shallow copy of it).\n * @signature\n *    forEachObj(fn)(object)\n * @example\n *    pipe(\n *      {a: 1},\n *      forEachObj((val, key) => console.log(`${key}: ${val}`))\n *    ) // \"a: 1\"\n * @dataLast\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): (object: T) => T;\n\nexport function forEachObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachObjImplementation, args);\n}\n\nfunction forEachObjImplementation<T extends object>(\n  data: T,\n  fn: (value: unknown, key: string, data: T) => void,\n): T {\n  for (const [key, value] of Object.entries(data)) {\n    fn(value, key, data);\n  }\n  return data;\n}\n"],"mappings":"kGA0DA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAOA,EAAAA,MAAM,EAA0B,EAAK,CAG9C,SAAS,EACP,EACA,EACG,CACH,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAC7C,EAAG,EAAO,EAAK,EAAK,CAEtB,OAAO"}
+{"version":3,"file":"for-each-obj.cjs","names":["curry"],"sources":["../src/for-each-obj.ts"],"sourcesContent":["import type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport { curry } from './curry';\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param data - The object who'se entries would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    forEachObj(object, fn)\n * @example\n *    forEachObj({a: 1}, (val, key, obj) => {\n *      console.log(`${key}: ${val}`)\n *    }) // \"a: 1\"\n * @dataFirst\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  data: T,\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): void;\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original object (the ref itself, not a shallow copy of it).\n * @signature\n *    forEachObj(fn)(object)\n * @example\n *    pipe(\n *      {a: 1},\n *      forEachObj((val, key) => console.log(`${key}: ${val}`))\n *    ) // \"a: 1\"\n * @dataLast\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): (object: T) => T;\n\nexport function forEachObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachObjImplementation, args);\n}\n\nfunction forEachObjImplementation<T extends object>(\n  data: T,\n  fn: (value: unknown, key: string, data: T) => void,\n): T {\n  for (const [key, value] of Object.entries(data)) {\n    fn(value, key, data);\n  }\n  return data;\n}\n"],"mappings":"kGA0DA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAOA,EAAAA,MAAM,EAA0B,CAAI,CAC7C,CAEA,SAAS,EACP,EACA,EACG,CACH,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,CAAI,EAC5C,EAAG,EAAO,EAAK,CAAI,EAErB,OAAO,CACT"}

package/dist/for-each-obj.js.map

@@ -1 +1 @@
-{"version":3,"file":"for-each-obj.js","names":[],"sources":["../src/for-each-obj.ts"],"sourcesContent":["import type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport { curry } from './curry';\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param data - The object who'se entries would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    forEachObj(object, fn)\n * @example\n *    forEachObj({a: 1}, (val, key, obj) => {\n *      console.log(`${key}: ${val}`)\n *    }) // \"a: 1\"\n * @dataFirst\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  data: T,\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): void;\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original object (the ref itself, not a shallow copy of it).\n * @signature\n *    forEachObj(fn)(object)\n * @example\n *    pipe(\n *      {a: 1},\n *      forEachObj((val, key) => console.log(`${key}: ${val}`))\n *    ) // \"a: 1\"\n * @dataLast\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): (object: T) => T;\n\nexport function forEachObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachObjImplementation, args);\n}\n\nfunction forEachObjImplementation<T extends object>(\n  data: T,\n  fn: (value: unknown, key: string, data: T) => void,\n): T {\n  for (const [key, value] of Object.entries(data)) {\n    fn(value, key, data);\n  }\n  return data;\n}\n"],"mappings":"mCA0DA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,EAAK,CAG9C,SAAS,EACP,EACA,EACG,CACH,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAC7C,EAAG,EAAO,EAAK,EAAK,CAEtB,OAAO"}
+{"version":3,"file":"for-each-obj.js","names":[],"sources":["../src/for-each-obj.ts"],"sourcesContent":["import type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport { curry } from './curry';\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param data - The object who'se entries would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    forEachObj(object, fn)\n * @example\n *    forEachObj({a: 1}, (val, key, obj) => {\n *      console.log(`${key}: ${val}`)\n *    }) // \"a: 1\"\n * @dataFirst\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  data: T,\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): void;\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original object (the ref itself, not a shallow copy of it).\n * @signature\n *    forEachObj(fn)(object)\n * @example\n *    pipe(\n *      {a: 1},\n *      forEachObj((val, key) => console.log(`${key}: ${val}`))\n *    ) // \"a: 1\"\n * @dataLast\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): (object: T) => T;\n\nexport function forEachObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachObjImplementation, args);\n}\n\nfunction forEachObjImplementation<T extends object>(\n  data: T,\n  fn: (value: unknown, key: string, data: T) => void,\n): T {\n  for (const [key, value] of Object.entries(data)) {\n    fn(value, key, data);\n  }\n  return data;\n}\n"],"mappings":"mCA0DA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,CAAI,CAC7C,CAEA,SAAS,EACP,EACA,EACG,CACH,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,CAAI,EAC5C,EAAG,EAAO,EAAK,CAAI,EAErB,OAAO,CACT"}

package/dist/for-each.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t,r)}function n(e,t){return e.forEach(t),e}function r(e){return(t,n,r)=>(e(t,n,r),{done:!1,hasNext:!0,next:t})}exports.forEach=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t,r)}function n(e,t){return e.forEach(t),e}function r(e){return(t,n,r)=>(e(t,n,r),{done:!1,hasNext:!0,next:t})}exports.forEach=t;
 //# sourceMappingURL=for-each.cjs.map