@vinicunca/perkakas 1.8.0 → 1.12.0

package/dist/find.d.cts

@@ -1,2 +1,64 @@
-import { find } from "./find-Bc-wGZYR.cjs";
-export { find };
+//#region src/find.d.ts
+/**
+ * Returns the first element in the provided array that satisfies the provided
+ * testing function. If no values satisfy the testing function, `undefined` is
+ * returned.
+ *
+ * Similar functions:
+ * `findLast` - If you need the last element that satisfies the provided testing function.
+ * `findIndex` - If you need the index of the found element in the array.
+ * `indexOf` - If you need to find the index of a value.
+ * `includes` - If you need to find if a value exists in an array.
+ * `some` - If you need to find if any element satisfies the provided testing function.
+ * `filter` - If you need to find all elements that satisfy the provided testing function.
+ *
+ * @param data - The items to search in.
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to indicate a matching element has been found, and
+ * `false` otherwise. A type-predicate can also be used to narrow the result.
+ * @returns The first element in the array that satisfies the provided testing
+ * function. Otherwise, `undefined` is returned.
+ * @signature
+ *    P.find(data, predicate)
+ * @example
+ *    P.find([1, 3, 4, 6], n => n % 2 === 0) // => 4
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function find<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined;
+declare function find<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): T | undefined;
+/**
+ * Returns the first element in the provided array that satisfies the provided
+ * testing function. If no values satisfy the testing function, `undefined` is
+ * returned.
+ *
+ * Similar functions:
+ * `findLast` - If you need the last element that satisfies the provided testing function.
+ * `findIndex` - If you need the index of the found element in the array.
+ * `indexOf` - If you need to find the index of a value.
+ * `includes` - If you need to find if a value exists in an array.
+ * `some` - If you need to find if any element satisfies the provided testing function.
+ * `filter` - If you need to find all elements that satisfy the provided testing function.
+ *
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to indicate a matching element has been found, and
+ * `false` otherwise. A type-predicate can also be used to narrow the result.
+ * @returns The first element in the array that satisfies the provided testing
+ * function. Otherwise, `undefined` is returned.
+ * @signature
+ *    P.find(predicate)(data)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.find(n => n % 2 === 0)
+ *    ) // => 4
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function find<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => S | undefined;
+declare function find<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => T | undefined;
+//#endregion
+export { find };
+//# sourceMappingURL=find.d.cts.map

package/dist/find.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.cts","names":[],"sources":["../src/find.ts"],"sourcesContent":[],"mappings":";;AAgCA;;;;;;;;;;AAIA;;;;;;;;AAkCA;;;;;;;;AAE+B,iBAxCf,IAwCe,CAAA,CAAA,EAAA,UAxCG,CAwCH,CAAA,CAAA,IAAA,EAvCvB,aAuCuB,CAvCT,CAuCS,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAtCV,CAsCU,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAtCc,aAsCd,CAtC4B,CAsC5B,CAAA,EAAA,GAAA,KAAA,IAtC4C,CAsC5C,CAAA,EArC5B,CAqC4B,GAAA,SAAA;AAAC,iBApChB,IAoCgB,CAAA,CAAA,CAAA,CAAA,IAAA,EAnCxB,aAmCwB,CAnCV,CAmCU,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAlCX,CAkCW,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAlCa,aAkCb,CAlC2B,CAkC3B,CAAA,EAAA,GAAA,OAAA,CAAA,EAjC7B,CAiC6B,GAAA,SAAA;AAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHgB,kBAAkB,sBACb,wBAAwB,cAAc,gBAAgB,WACjE,cAAc,OAAO;iBACf,2BACK,wBAAwB,cAAc,wBACjD,cAAc,OAAO"}

package/dist/find.d.ts

@@ -1,2 +1,64 @@
-import { find } from "./find-7ahTlXcE.js";
-export { find };
+//#region src/find.d.ts
+/**
+ * Returns the first element in the provided array that satisfies the provided
+ * testing function. If no values satisfy the testing function, `undefined` is
+ * returned.
+ *
+ * Similar functions:
+ * `findLast` - If you need the last element that satisfies the provided testing function.
+ * `findIndex` - If you need the index of the found element in the array.
+ * `indexOf` - If you need to find the index of a value.
+ * `includes` - If you need to find if a value exists in an array.
+ * `some` - If you need to find if any element satisfies the provided testing function.
+ * `filter` - If you need to find all elements that satisfy the provided testing function.
+ *
+ * @param data - The items to search in.
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to indicate a matching element has been found, and
+ * `false` otherwise. A type-predicate can also be used to narrow the result.
+ * @returns The first element in the array that satisfies the provided testing
+ * function. Otherwise, `undefined` is returned.
+ * @signature
+ *    P.find(data, predicate)
+ * @example
+ *    P.find([1, 3, 4, 6], n => n % 2 === 0) // => 4
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function find<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined;
+declare function find<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): T | undefined;
+/**
+ * Returns the first element in the provided array that satisfies the provided
+ * testing function. If no values satisfy the testing function, `undefined` is
+ * returned.
+ *
+ * Similar functions:
+ * `findLast` - If you need the last element that satisfies the provided testing function.
+ * `findIndex` - If you need the index of the found element in the array.
+ * `indexOf` - If you need to find the index of a value.
+ * `includes` - If you need to find if a value exists in an array.
+ * `some` - If you need to find if any element satisfies the provided testing function.
+ * `filter` - If you need to find all elements that satisfy the provided testing function.
+ *
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to indicate a matching element has been found, and
+ * `false` otherwise. A type-predicate can also be used to narrow the result.
+ * @returns The first element in the array that satisfies the provided testing
+ * function. Otherwise, `undefined` is returned.
+ * @signature
+ *    P.find(predicate)(data)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.find(n => n % 2 === 0)
+ *    ) // => 4
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function find<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => S | undefined;
+declare function find<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => T | undefined;
+//#endregion
+export { find };
+//# sourceMappingURL=find.d.ts.map

package/dist/find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","names":[],"sources":["../src/find.ts"],"sourcesContent":[],"mappings":";;AAgCA;;;;;;;;;;AAIA;;;;;;;;AAkCA;;;;;;;;AAE+B,iBAxCf,IAwCe,CAAA,CAAA,EAAA,UAxCG,CAwCH,CAAA,CAAA,IAAA,EAvCvB,aAuCuB,CAvCT,CAuCS,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAtCV,CAsCU,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAtCc,aAsCd,CAtC4B,CAsC5B,CAAA,EAAA,GAAA,KAAA,IAtC4C,CAsC5C,CAAA,EArC5B,CAqC4B,GAAA,SAAA;AAAC,iBApChB,IAoCgB,CAAA,CAAA,CAAA,CAAA,IAAA,EAnCxB,aAmCwB,CAnCV,CAmCU,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAlCX,CAkCW,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAlCa,aAkCb,CAlC2B,CAkC3B,CAAA,EAAA,GAAA,OAAA,CAAA,EAjC7B,CAiC6B,GAAA,SAAA;AAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHgB,kBAAkB,sBACb,wBAAwB,cAAc,gBAAgB,WACjE,cAAc,OAAO;iBACf,2BACK,wBAAwB,cAAc,wBACjD,cAAc,OAAO"}

package/dist/find.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./utility-evaluators-CnQVdcZv.js";import"./to-single-bHVECPzX.js";import{find as e}from"./find-DR6lM3gh.js";export{e as find};
+import{t as e}from"./curry-BcQ8Up1_.js";import{t}from"./utility-evaluators-BwYLtB8b.js";import{t as n}from"./to-single-vYpRavjM.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

@@ -0,0 +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 *    P.find(data, predicate)\n * @example\n *    P.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 *    P.find(predicate)(data)\n * @example\n *    P.pipe(\n *      [1, 3, 4, 6],\n *      P.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>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): S | undefined {\n  return data.find(predicate);\n}\n\nfunction lazyImplementation<T, S extends T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): 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":"oIA6EA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAM,EAAS,EAAmB,CAAC,CAGtE,SAAS,EACP,EACA,EACe,CACf,OAAO,EAAK,KAAK,EAAU,CAG7B,SAAS,EACP,EACqB,CACrB,OAAQ,EAAO,EAAO,IACpB,EAAU,EAAO,EAAO,EAAK,CACzB,CAAE,KAAM,GAAM,QAAS,GAAM,KAAM,EAAO,CAC1C"}

package/dist/first-by.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./curry-order-rules-UcuuWkKd.cjs`),require(`./has-at-least-D-ahiJB6.cjs`);const e=require(`./first-by-BzxRBZ5J.cjs`);exports.firstBy=e.firstBy;
+const e=require(`./curry-order-rules-ClqHrs8_.cjs`),t=require(`./has-at-least-BXwOPLQK.cjs`);function n(...t){return e.t(r,t)}function r(e,n){if(!t.t(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;

package/dist/first-by.d.cts

@@ -1,5 +1,60 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import "./non-empty-array-D3ZRHApS.cjs";
-import "./curry-order-rules-1zjlAgqa.cjs";
-import { firstBy } from "./first-by-Dm9iyhMz.cjs";
-export { firstBy };
+import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+import { t as NonEmptyArray } from "./non-empty-array-CFG7wGD-.cjs";
+import { t as OrderRule } from "./curry-order-rules-cezUWcSx.cjs";
+
+//#region src/first-by.d.ts
+type FirstBy<T extends IterableContainer> = T[number] | (T extends readonly [unknown, ...ReadonlyArray<unknown>] ? never : T extends readonly [...ReadonlyArray<unknown>, unknown] ? never : undefined);
+/**
+ * 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 `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.
+ *
+ * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
+ *
+ * @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.
+ * @returns The first element by the order criteria, or `undefined` if the array
+ * is empty. (The function provides strong typing if the input type assures the
+ * array isn't empty).
+ * @signature
+ *   P.firstBy(...rules)(data);
+ * @example
+ *   const max = P.pipe([1,2,3], P.firstBy([P.identity(), "desc"])); // => 3;
+ *   const min = P.pipe([1,2,3], P.firstBy(P.identity())); // => 1;
+ *
+ *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
+ *   const maxBy = P.pipe(data, P.firstBy([(item) => item.a.length, "desc"])); // => { a: "aaa" };
+ *   const minBy = P.pipe(data, P.firstBy((item) => item.a.length)); // => { a: "a" };
+ *
+ *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
+ *   const multi = P.pipe(data, P.firstBy(P.prop('type'), [P.prop('size'), 'desc'])); // => {type: "cat", size: 2}
+ * @dataLast
+ * @category Array
+ */
+declare function firstBy<T extends IterableContainer>(...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => FirstBy<T>;
+/**
+ * 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 `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.
+ *
+ * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
+ *
+ * @param data - An array of items.
+ * @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.
+ * @returns The first element by the order criteria, or `undefined` if the array
+ * is empty. (The function provides strong typing if the input type assures the
+ * array isn't empty).
+ * @signature
+ *   P.firstBy(data, ...rules);
+ * @example
+ *   const max = P.firstBy([1,2,3], [P.identity(), "desc"]); // => 3;
+ *   const min = P.firstBy([1,2,3], P.identity()); // => 1;
+ *
+ *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
+ *   const maxBy = P.firstBy(data, [(item) => item.a.length, "desc"]); // => { a: "aaa" };
+ *   const minBy = P.firstBy(data, (item) => item.a.length); // => { a: "a" };
+ *
+ *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
+ *   const multi = P.firstBy(data, P.prop('type'), [P.prop('size'), 'desc']); // => {type: "cat", size: 2}
+ * @dataFirst
+ * @category Array
+ */
+declare function firstBy<T extends IterableContainer>(data: T, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): FirstBy<T>;
+//#endregion
+export { firstBy };
+//# sourceMappingURL=first-by.d.cts.map

package/dist/first-by.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first-by.d.cts","names":[],"sources":["../src/first-by.ts"],"sourcesContent":[],"mappings":";;;;;KAOK,kBAAkB,qBACjB,aACC,gCAAgC,kCAE/B,uBAAuB;;AARuC;;;;;;;;AAoCtE;;;;;;;;;;AA6BA;;;;;AAEqB,iBA/BL,OA+BK,CAAA,UA/Ba,iBA+Bb,CAAA,CAAA,GAAA,KAAA,EA9BT,QA8BS,CA9BA,aA8BA,CA9Bc,SA8Bd,CA9BwB,CA8BxB,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,IAAA,EA7BX,CA6BW,EAAA,GA7BL,OA6BK,CA7BG,CA6BH,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;iBAFL,kBAAkB,yBAC1B,aACI,SAAS,cAAc,UAAU,eAC1C,QAAQ"}

package/dist/first-by.d.ts

@@ -1,5 +1,60 @@
-import "./iterable-container-wtkYslN_.js";
-import "./non-empty-array-D3HWDPMt.js";
-import "./curry-order-rules-Cthu8rj4.js";
-import { firstBy } from "./first-by-C0qf5rwh.js";
-export { firstBy };
+import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+import { t as NonEmptyArray } from "./non-empty-array-DXkY7ynY.js";
+import { t as OrderRule } from "./curry-order-rules-BCcwbNxd.js";
+
+//#region src/first-by.d.ts
+type FirstBy<T extends IterableContainer> = T[number] | (T extends readonly [unknown, ...ReadonlyArray<unknown>] ? never : T extends readonly [...ReadonlyArray<unknown>, unknown] ? never : undefined);
+/**
+ * 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 `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.
+ *
+ * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
+ *
+ * @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.
+ * @returns The first element by the order criteria, or `undefined` if the array
+ * is empty. (The function provides strong typing if the input type assures the
+ * array isn't empty).
+ * @signature
+ *   P.firstBy(...rules)(data);
+ * @example
+ *   const max = P.pipe([1,2,3], P.firstBy([P.identity(), "desc"])); // => 3;
+ *   const min = P.pipe([1,2,3], P.firstBy(P.identity())); // => 1;
+ *
+ *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
+ *   const maxBy = P.pipe(data, P.firstBy([(item) => item.a.length, "desc"])); // => { a: "aaa" };
+ *   const minBy = P.pipe(data, P.firstBy((item) => item.a.length)); // => { a: "a" };
+ *
+ *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
+ *   const multi = P.pipe(data, P.firstBy(P.prop('type'), [P.prop('size'), 'desc'])); // => {type: "cat", size: 2}
+ * @dataLast
+ * @category Array
+ */
+declare function firstBy<T extends IterableContainer>(...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => FirstBy<T>;
+/**
+ * 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 `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.
+ *
+ * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
+ *
+ * @param data - An array of items.
+ * @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.
+ * @returns The first element by the order criteria, or `undefined` if the array
+ * is empty. (The function provides strong typing if the input type assures the
+ * array isn't empty).
+ * @signature
+ *   P.firstBy(data, ...rules);
+ * @example
+ *   const max = P.firstBy([1,2,3], [P.identity(), "desc"]); // => 3;
+ *   const min = P.firstBy([1,2,3], P.identity()); // => 1;
+ *
+ *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
+ *   const maxBy = P.firstBy(data, [(item) => item.a.length, "desc"]); // => { a: "aaa" };
+ *   const minBy = P.firstBy(data, (item) => item.a.length); // => { a: "a" };
+ *
+ *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
+ *   const multi = P.firstBy(data, P.prop('type'), [P.prop('size'), 'desc']); // => {type: "cat", size: 2}
+ * @dataFirst
+ * @category Array
+ */
+declare function firstBy<T extends IterableContainer>(data: T, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): FirstBy<T>;
+//#endregion
+export { firstBy };
+//# sourceMappingURL=first-by.d.ts.map

package/dist/first-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first-by.d.ts","names":[],"sources":["../src/first-by.ts"],"sourcesContent":[],"mappings":";;;;;KAOK,kBAAkB,qBACjB,aACC,gCAAgC,kCAE/B,uBAAuB;;AARuC;;;;;;;;AAoCtE;;;;;;;;;;AA6BA;;;;;AAEqB,iBA/BL,OA+BK,CAAA,UA/Ba,iBA+Bb,CAAA,CAAA,GAAA,KAAA,EA9BT,QA8BS,CA9BA,aA8BA,CA9Bc,SA8Bd,CA9BwB,CA8BxB,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,IAAA,EA7BX,CA6BW,EAAA,GA7BL,OA6BK,CA7BG,CA6BH,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;iBAFL,kBAAkB,yBAC1B,aACI,SAAS,cAAc,UAAU,eAC1C,QAAQ"}

package/dist/first-by.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./curry-order-rules-BuA7D1F4.js";import"./has-at-least-6iRvhsST.js";import{firstBy as e}from"./first-by-B5IsCexF.js";export{e as firstBy};
+import{t as e}from"./curry-order-rules-C6bwcUwC.js";import{t}from"./has-at-least-DyIhWZJH.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

@@ -0,0 +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 `P.first(P.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 *   P.firstBy(...rules)(data);\n * @example\n *   const max = P.pipe([1,2,3], P.firstBy([P.identity(), \"desc\"])); // => 3;\n *   const min = P.pipe([1,2,3], P.firstBy(P.identity())); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = P.pipe(data, P.firstBy([(item) => item.a.length, \"desc\"])); // => { a: \"aaa\" };\n *   const minBy = P.pipe(data, P.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 = P.pipe(data, P.firstBy(P.prop('type'), [P.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 `P.first(P.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 *   P.firstBy(data, ...rules);\n * @example\n *   const max = P.firstBy([1,2,3], [P.identity(), \"desc\"]); // => 3;\n *   const min = P.firstBy([1,2,3], P.identity()); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = P.firstBy(data, [(item) => item.a.length, \"desc\"]); // => { a: \"aaa\" };\n *   const minBy = P.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 = P.firstBy(data, P.prop('type'), [P.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":"8FAyEA,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"}

package/dist/first.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./to-single-Bnq9l8Zp.cjs`);const e=require(`./first-Dbxt3OEg.cjs`);exports.first=e.first;
+const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./to-single-Chq_hKEk.cjs`);function n(...n){return e.t(r,n,t.t(i))}function r([e]){return e}function i(){return a}function a(e){return{hasNext:!0,next:e,done:!0}}exports.first=n;

package/dist/first.d.cts

@@ -1,3 +1,40 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import { first } from "./first-C3rp67g0.cjs";
-export { first };
+import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+
+//#region src/first.d.ts
+type First<T extends IterableContainer> = T extends [] ? undefined : T extends readonly [unknown, ...Array<unknown>] ? T[0] : T extends readonly [...infer Pre, infer Last] ? Last | Pre[0] : T[0] | undefined;
+/**
+ * Gets the first element of `array`.
+ *
+ * @param data - The array.
+ * @returns The first element of the array.
+ * @signature
+ *    P.first(array)
+ * @example
+ *    P.first([1, 2, 3]) // => 1
+ *    P.first([]) // => undefined
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function first<T extends IterableContainer>(data: T): First<T>;
+/**
+ * Gets the first element of `array`.
+ *
+ * @returns The first element of the array.
+ * @signature
+ *    P.first()(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 4, 8, 16],
+ *      P.filter(x => x > 3),
+ *      P.first(),
+ *      x => x + 1
+ *    ); // => 5
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function first(): <T extends IterableContainer>(data: T) => First<T>;
+//#endregion
+export { first };
+//# sourceMappingURL=first.d.cts.map

package/dist/first.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first.d.cts","names":[],"sources":["../src/first.ts"],"sourcesContent":[],"mappings":";;;KAKK,gBAAgB,qBAAqB,2BAEtC,gCAAgC,kBAC9B,OACA,gDACE,OAAO,SACP;;AAXqE;;;;;;;;;;;AA2B7E;;AAAyD,iBAAzC,KAAyC,CAAA,UAAzB,iBAAyB,CAAA,CAAA,IAAA,EAAA,CAAA,CAAA,EAAI,KAAJ,CAAU,CAAV,CAAA;;;;AAmBzD;;;;;;;;;;;;;;iBAAgB,KAAA,CAAA,cAAoB,yBAAyB,MAAM,MAAM"}

package/dist/first.d.ts

@@ -1,3 +1,40 @@
-import "./iterable-container-wtkYslN_.js";
-import { first } from "./first-1NtfTucX.js";
-export { first };
+import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+
+//#region src/first.d.ts
+type First<T extends IterableContainer> = T extends [] ? undefined : T extends readonly [unknown, ...Array<unknown>] ? T[0] : T extends readonly [...infer Pre, infer Last] ? Last | Pre[0] : T[0] | undefined;
+/**
+ * Gets the first element of `array`.
+ *
+ * @param data - The array.
+ * @returns The first element of the array.
+ * @signature
+ *    P.first(array)
+ * @example
+ *    P.first([1, 2, 3]) // => 1
+ *    P.first([]) // => undefined
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function first<T extends IterableContainer>(data: T): First<T>;
+/**
+ * Gets the first element of `array`.
+ *
+ * @returns The first element of the array.
+ * @signature
+ *    P.first()(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 4, 8, 16],
+ *      P.filter(x => x > 3),
+ *      P.first(),
+ *      x => x + 1
+ *    ); // => 5
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function first(): <T extends IterableContainer>(data: T) => First<T>;
+//#endregion
+export { first };
+//# sourceMappingURL=first.d.ts.map

package/dist/first.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first.d.ts","names":[],"sources":["../src/first.ts"],"sourcesContent":[],"mappings":";;;KAKK,gBAAgB,qBAAqB,2BAEtC,gCAAgC,kBAC9B,OACA,gDACE,OAAO,SACP;;AAXqE;;;;;;;;;;;AA2B7E;;AAAyD,iBAAzC,KAAyC,CAAA,UAAzB,iBAAyB,CAAA,CAAA,IAAA,EAAA,CAAA,CAAA,EAAI,KAAJ,CAAU,CAAV,CAAA;;;;AAmBzD;;;;;;;;;;;;;;iBAAgB,KAAA,CAAA,cAAoB,yBAAyB,MAAM,MAAM"}

package/dist/first.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./to-single-bHVECPzX.js";import{first as e}from"./first-DDQc8owl.js";export{e as first};
+import{t as e}from"./curry-BcQ8Up1_.js";import{t}from"./to-single-vYpRavjM.js";function n(...n){return e(r,n,t(i))}function r([e]){return e}function i(){return a}function a(e){return{hasNext:!0,next:e,done:!0}}export{n as first};
+//# sourceMappingURL=first.js.map

package/dist/first.js.map

@@ -0,0 +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 *    P.first(array)\n * @example\n *    P.first([1, 2, 3]) // => 1\n *    P.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 *    P.first()(array)\n * @example\n *    P.pipe(\n *      [1, 2, 4, 8, 16],\n *      P.filter(x => x > 3),\n *      P.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\nfunction firstImplementation<T>([item]: ReadonlyArray<T>): T | undefined {\n  return item;\n}\n\nfunction lazyImplementation(): LazyEvaluator {\n  return firstLazy;\n}\n\n// eslint-disable-next-line ts/explicit-function-return-type\nfunction firstLazy<T>(value: T) {\n  return ({ hasNext: true, next: value, done: true }) as const;\n}\n"],"mappings":"+EAgDA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAM,EAAS,EAAmB,CAAC,CAGvE,SAAS,EAAuB,CAAC,GAAwC,CACvE,OAAO,EAGT,SAAS,GAAoC,CAC3C,OAAO,EAIT,SAAS,EAAa,EAAU,CAC9B,MAAQ,CAAE,QAAS,GAAM,KAAM,EAAO,KAAM,GAAM"}

package/dist/flat-map.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./flat-map-BI-sJd2B.cjs`);exports.flatMap=e.flatMap;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(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;

package/dist/flat-map.d.cts

@@ -1,2 +1,47 @@
-import { flatMap } from "./flat-map-Do5YLueq.cjs";
-export { flatMap };
+//#region src/flat-map.d.ts
+/**
+ * Returns a new array formed by applying a given callback function to each
+ * element of the array, and then flattening the result by one level. It is
+ * identical to a `map` followed by a `flat` of depth 1
+ * (`flat(map(data, ...args))`), but slightly more efficient than calling those
+ * two methods separately. Equivalent to `Array.prototype.flatMap`.
+ *
+ * @param data - The items to map and flatten.
+ * @param callbackfn - A function to execute for each element in the array. It
+ * should return an array containing new elements of the new array, or a single
+ * non-array value to be added to the new array.
+ * @returns A new array with each element being the result of the callback
+ * function and flattened by a depth of 1.
+ * @signature
+ *    P.flatMap(data, callbackfn)
+ * @example
+ *    P.flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function flatMap<T, U>(data: ReadonlyArray<T>, callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): Array<U>;
+/**
+ * Returns a new array formed by applying a given callback function to each
+ * element of the array, and then flattening the result by one level. It is
+ * identical to a `map` followed by a `flat` of depth 1
+ * (`flat(map(data, ...args))`), but slightly more efficient than calling those
+ * two methods separately. Equivalent to `Array.prototype.flatMap`.
+ *
+ * @param callbackfn - A function to execute for each element in the array. It
+ * should return an array containing new elements of the new array, or a single
+ * non-array value to be added to the new array.
+ * @returns A new array with each element being the result of the callback
+ * function and flattened by a depth of 1.
+ * @signature
+ *    P.flatMap(callbackfn)(data)
+ * @example
+ *    P.pipe([1, 2, 3], P.flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function flatMap<T, U>(callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): (data: ReadonlyArray<T>) => Array<U>;
+//#endregion
+export { flatMap };
+//# sourceMappingURL=flat-map.d.cts.map

package/dist/flat-map.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat-map.d.cts","names":[],"sources":["../src/flat-map.ts"],"sourcesContent":[],"mappings":";;AAyBA;;;;;;;;;;;;AA6BA;;;;;;;;AAMU,iBAnCM,OAmCN,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAlCF,aAkCE,CAlCY,CAkCZ,CAAA,EAAA,UAAA,EAAA,CAAA,KAAA,EAhCC,CAgCD,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EA9BA,aA8BA,CA9Bc,CA8Bd,CAAA,EAAA,GA7BH,aA6BG,CA7BW,CA6BX,CAAA,GA7BgB,CA6BhB,CAAA,EA5BP,KA4BO,CA5BD,CA4BC,CAAA;;;;;;;;;;;;;;;;;;;;;iBANM,kCAEL,wBAED,cAAc,OACjB,cAAc,KAAK,WAChB,cAAc,OAAO,MAAM"}

package/dist/flat-map.d.ts

@@ -1,2 +1,47 @@
-import { flatMap } from "./flat-map-Ok5sZOb2.js";
-export { flatMap };
+//#region src/flat-map.d.ts
+/**
+ * Returns a new array formed by applying a given callback function to each
+ * element of the array, and then flattening the result by one level. It is
+ * identical to a `map` followed by a `flat` of depth 1
+ * (`flat(map(data, ...args))`), but slightly more efficient than calling those
+ * two methods separately. Equivalent to `Array.prototype.flatMap`.
+ *
+ * @param data - The items to map and flatten.
+ * @param callbackfn - A function to execute for each element in the array. It
+ * should return an array containing new elements of the new array, or a single
+ * non-array value to be added to the new array.
+ * @returns A new array with each element being the result of the callback
+ * function and flattened by a depth of 1.
+ * @signature
+ *    P.flatMap(data, callbackfn)
+ * @example
+ *    P.flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function flatMap<T, U>(data: ReadonlyArray<T>, callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): Array<U>;
+/**
+ * Returns a new array formed by applying a given callback function to each
+ * element of the array, and then flattening the result by one level. It is
+ * identical to a `map` followed by a `flat` of depth 1
+ * (`flat(map(data, ...args))`), but slightly more efficient than calling those
+ * two methods separately. Equivalent to `Array.prototype.flatMap`.
+ *
+ * @param callbackfn - A function to execute for each element in the array. It
+ * should return an array containing new elements of the new array, or a single
+ * non-array value to be added to the new array.
+ * @returns A new array with each element being the result of the callback
+ * function and flattened by a depth of 1.
+ * @signature
+ *    P.flatMap(callbackfn)(data)
+ * @example
+ *    P.pipe([1, 2, 3], P.flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function flatMap<T, U>(callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): (data: ReadonlyArray<T>) => Array<U>;
+//#endregion
+export { flatMap };
+//# sourceMappingURL=flat-map.d.ts.map

package/dist/flat-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat-map.d.ts","names":[],"sources":["../src/flat-map.ts"],"sourcesContent":[],"mappings":";;AAyBA;;;;;;;;;;;;AA6BA;;;;;;;;AAMU,iBAnCM,OAmCN,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAlCF,aAkCE,CAlCY,CAkCZ,CAAA,EAAA,UAAA,EAAA,CAAA,KAAA,EAhCC,CAgCD,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EA9BA,aA8BA,CA9Bc,CA8Bd,CAAA,EAAA,GA7BH,aA6BG,CA7BW,CA6BX,CAAA,GA7BgB,CA6BhB,CAAA,EA5BP,KA4BO,CA5BD,CA4BC,CAAA;;;;;;;;;;;;;;;;;;;;;iBANM,kCAEL,wBAED,cAAc,OACjB,cAAc,KAAK,WAChB,cAAc,OAAO,MAAM"}

package/dist/flat-map.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{flatMap as e}from"./flat-map-1WAgW39N.js";export{e as flatMap};
+import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(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}}}export{t as flatMap};
+//# sourceMappingURL=flat-map.js.map

package/dist/flat-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat-map.js","names":[],"sources":["../src/flat-map.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\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 *    P.flatMap(data, callbackfn)\n * @example\n *    P.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: (\n    input: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => 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 *    P.flatMap(callbackfn)(data)\n * @example\n *    P.pipe([1, 2, 3], P.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: (\n    input: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => 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>(\n  data: ReadonlyArray<T>,\n  callbackfn: (\n    value: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => ReadonlyArray<U> | U,\n): Array<U> {\n  return data.flatMap(callbackfn);\n}\n\nfunction lazyImplementation<T, K>(\n  callbackfn: (\n    input: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => K | ReadonlyArray<K>,\n): LazyEvaluator<T, K> {\n  // @ts-expect-error [ts2322] - We need to make LazyMany better so it accommodate the typing here...\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":"wCA8DA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAM,EAAmB,CAG/D,SAAS,EACP,EACA,EAKU,CACV,OAAO,EAAK,QAAQ,EAAW,CAGjC,SAAS,EACP,EAKqB,CAErB,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"}

package/dist/flat.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./utility-evaluators-DqJcWENu.cjs`);const e=require(`./flat-BayJJsR-.cjs`);exports.flat=e.flat;
+const e=require(`./lazy-data-last-impl-D4kLybyP.cjs`),t=require(`./utility-evaluators-CAbODbuk.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;