@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/filter.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.cts","names":[],"sources":["../src/filter.ts"],"sourcesContent":[],"mappings":";;;;;KAWK,kCACO,qEAEQ,iBAKhB,MAAM,aACN,8BAGE,SAAS;;AArB8D;;;;;;;;;AA4C7E;;;;;;;;;AAMG,iBANa,MAMb,CAAA,UALS,iBAKT,EAAA,kBAJiB,CAIjB,CAAA,MAAA,CAAA,CAAA,CAAA,IAAA,EAFK,CAEL,EAAA,SAAA,EAAA,CAAA,KAAA,EADkB,CAClB,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADkD,CAClD,EAAA,GAAA,KAAA,IADiE,SACjE,CAAA,EAAA,aAAA,CAAc,CAAd,EAAiB,SAAjB,CAAA;AAAa,iBACA,MADA,CAAA,UAEJ,iBAFI,EAAA,uBAAA,OAAA,CAAA,CAAA,IAAA,EAKR,CALQ,EAAA,SAAA,EAAA,CAAA,KAAA,EAMK,CANL,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAMqC,CANrC,EAAA,GAM2C,cAN3C,CAAA,EAOb,uBAPa,CAOW,CAPX,EAOc,cAPd,CAAA;AAChB;;;;;;;;;;AA0BA;;;;;;;;AAKiC,iBALjB,MAKiB,CAAA,UAJrB,iBAIqB,EAAA,kBAHb,CAGa,CAAA,MAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EADZ,CACY,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADoB,CACpB,EAAA,GAAA,KAAA,IADmC,SACnC,CAAA,EAAA,CAAA,IAAA,EAAvB,CAAuB,EAAA,GAAjB,aAAiB,CAAH,CAAG,EAAA,SAAA,CAAA;AAAjB,iBACA,MADA,CAAA,UAEJ,iBAFI,EAAA,uBAAA,OAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAKK,CALL,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAKqC,CALrC,EAAA,GAK2C,cAL3C,CAAA,EAAA,CAAA,IAAA,EAMN,CANM,EAAA,GAMA,uBANA,CAMwB,CANxB,EAM2B,cAN3B,CAAA"}

package/dist/filter.d.ts

@@ -1,7 +1,50 @@
-import "./iterable-container-F9CDF7ym.js";
-import "./perkakas-type-error-2yBU0Drj.js";
-import "./tuple-parts-Du2iVN8H.js";
-import "./coerced-array-Fezc8pIu.js";
-import "./filtered-array-CPOk8m8s.js";
-import { filter } from "./filter-Bg-TEmtZ.js";
-export { filter };
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
+import { t as FilteredArray } from "./filtered-array-wtIEwdU7.js";
+import { Writable } from "type-fest";
+
+//#region src/filter.d.ts
+type NonRefinedFilteredArray<T extends IterableContainer, IsItemIncluded extends boolean> = boolean extends IsItemIncluded ? Array<T[number]> : IsItemIncluded extends true ? Writable<T> : [];
+/**
+ * Creates a shallow copy of a portion of a given array, filtered down to just
+ * the elements from the given array that pass the test implemented by the
+ * provided function. Equivalent to `Array.prototype.filter`.
+ *
+ * @param data - The array to filter.
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to keep the element in the resulting array, and `false`
+ * otherwise. A type-predicate can also be used to narrow the result.
+ * @returns A shallow copy of the given array containing just the elements that
+ * pass the test. If no elements pass the test, an empty array is returned.
+ * @signature
+ *    P.filter(data, predicate)
+ * @example
+ *    P.filter([1, 2, 3], x => x % 2 === 1) // => [1, 3]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function filter<T extends IterableContainer, Condition extends T[number]>(data: T, predicate: (value: T[number], index: number, data: T) => value is Condition): FilteredArray<T, Condition>;
+declare function filter<T extends IterableContainer, IsItemIncluded extends boolean>(data: T, predicate: (value: T[number], index: number, data: T) => IsItemIncluded): NonRefinedFilteredArray<T, IsItemIncluded>;
+/**
+ * Creates a shallow copy of a portion of a given array, filtered down to just
+ * the elements from the given array that pass the test implemented by the
+ * provided function. Equivalent to `Array.prototype.filter`.
+ *
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to keep the element in the resulting array, and `false`
+ * otherwise.
+ * @returns A shallow copy of the given array containing just the elements that
+ * pass the test. If no elements pass the test, an empty array is returned.
+ * @signature
+ *    P.filter(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 3], P.filter(x => x % 2 === 1)) // => [1, 3]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function filter<T extends IterableContainer, Condition extends T[number]>(predicate: (value: T[number], index: number, data: T) => value is Condition): (data: T) => FilteredArray<T, Condition>;
+declare function filter<T extends IterableContainer, IsItemIncluded extends boolean>(predicate: (value: T[number], index: number, data: T) => IsItemIncluded): (data: T) => NonRefinedFilteredArray<T, IsItemIncluded>;
+//#endregion
+export { filter };
+//# sourceMappingURL=filter.d.ts.map

package/dist/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","names":[],"sources":["../src/filter.ts"],"sourcesContent":[],"mappings":";;;;;KAWK,kCACO,qEAEQ,iBAKhB,MAAM,aACN,8BAGE,SAAS;;AArB8D;;;;;;;;;AA4C7E;;;;;;;;;AAMG,iBANa,MAMb,CAAA,UALS,iBAKT,EAAA,kBAJiB,CAIjB,CAAA,MAAA,CAAA,CAAA,CAAA,IAAA,EAFK,CAEL,EAAA,SAAA,EAAA,CAAA,KAAA,EADkB,CAClB,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADkD,CAClD,EAAA,GAAA,KAAA,IADiE,SACjE,CAAA,EAAA,aAAA,CAAc,CAAd,EAAiB,SAAjB,CAAA;AAAa,iBACA,MADA,CAAA,UAEJ,iBAFI,EAAA,uBAAA,OAAA,CAAA,CAAA,IAAA,EAKR,CALQ,EAAA,SAAA,EAAA,CAAA,KAAA,EAMK,CANL,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAMqC,CANrC,EAAA,GAM2C,cAN3C,CAAA,EAOb,uBAPa,CAOW,CAPX,EAOc,cAPd,CAAA;AAChB;;;;;;;;;;AA0BA;;;;;;;;AAKiC,iBALjB,MAKiB,CAAA,UAJrB,iBAIqB,EAAA,kBAHb,CAGa,CAAA,MAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EADZ,CACY,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADoB,CACpB,EAAA,GAAA,KAAA,IADmC,SACnC,CAAA,EAAA,CAAA,IAAA,EAAvB,CAAuB,EAAA,GAAjB,aAAiB,CAAH,CAAG,EAAA,SAAA,CAAA;AAAjB,iBACA,MADA,CAAA,UAEJ,iBAFI,EAAA,uBAAA,OAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAKK,CALL,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAKqC,CALrC,EAAA,GAK2C,cAL3C,CAAA,EAAA,CAAA,IAAA,EAMN,CANM,EAAA,GAMA,uBANA,CAMwB,CANxB,EAM2B,cAN3B,CAAA"}

package/dist/filter.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./utility-evaluators-CnQVdcZv.js";import{filter as e}from"./filter-CH_YQe9A.js";export{e as filter};
+import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./utility-evaluators-Boc-TMbq.js";function n(...t){return e(r,t,i)}function r(e,t){return e.filter(t)}function i(e){return(n,r,i)=>e(n,r,i)?{done:!1,hasNext:!0,next:n}:t}export{n as filter};
+//# sourceMappingURL=filter.js.map

package/dist/filter.js.map

@@ -0,0 +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 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 *    P.filter(data, predicate)\n * @example\n *    P.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 *    P.filter(predicate)(data)\n * @example\n *    P.pipe([1, 2, 3], P.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>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, array: ReadonlyArray<T>) => boolean,\n): Array<T> {\n  return data.filter(predicate);\n};\n\nfunction lazyImplementation<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): 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":"wFA4FA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAM,EAAmB,CAG9D,SAAS,EACP,EACA,EACU,CACV,OAAO,EAAK,OAAO,EAAU,CAG/B,SAAS,EACP,EACkB,CAClB,OAAQ,EAAO,EAAO,IACpB,EAAU,EAAO,EAAO,EAAK,CACzB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,CAC3C"}

package/dist/filtered-array-C--8loav.d.cts

@@ -0,0 +1,22 @@
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
+import { t as PartialArray } from "./partial-array-CQF5oggb.cjs";
+import { t as TupleParts } from "./tuple-parts-CzQQupgi.cjs";
+import { t as CoercedArray } from "./coerced-array-BKR9Bvsl.cjs";
+import { IsNever } from "type-fest";
+
+//#region src/internal/types/filtered-array.d.ts
+type FilteredArray<T extends IterableContainer, Condition> = T extends unknown ? [...FilteredFixedTuple<TupleParts<T>['required'], Condition>, ...PartialArray<FilteredFixedTuple<TupleParts<T>['optional'], Condition>>, ...CoercedArray<SymmetricRefine<TupleParts<T>['item'], Condition>>, ...FilteredFixedTuple<TupleParts<T>['suffix'], Condition>] : never;
+type FilteredFixedTuple<T, Condition, Output extends Array<unknown> = []> = T extends readonly [infer Head, ...infer Rest] ? FilteredFixedTuple<Rest, Condition, Head extends Condition ? [...Output, Head] : Head | Condition extends object ? Output : Condition extends Head ? Output | [...Output, Condition] : Output> : Output;
+type SymmetricRefine<Item, Condition> = Item extends Condition ? Item : Condition extends Item ? Condition : RefineIncomparable<Item, Condition>;
+/**
+ * When types are incomparable (neither one extends the other) they might still
+ * have a common refinement; this can happen when two objects share one or more
+ * prop while both having distinct props too (e.g., `{ a: string; b: number }`
+ * and `{ b: number, c: boolean }`), or when a prop is wider in one of them,
+ * allowing more value types than the other (e.g.,
+ * `{ a: "cat" | "dog", b: number }` and `{ a: "cat" }`).
+ */
+type RefineIncomparable<Item, Condition> = Item extends Record<PropertyKey, unknown> ? Condition extends Record<PropertyKey, unknown> ? IsNever<Extract<keyof Item, keyof Condition>> extends true ? never : Item & Condition : never : never;
+//#endregion
+export { FilteredArray as t };
+//# sourceMappingURL=filtered-array-C--8loav.d.cts.map

package/dist/filtered-array-C--8loav.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filtered-array-C--8loav.d.cts","names":[],"sources":["../src/internal/types/filtered-array.ts"],"sourcesContent":[],"mappings":";;;;;;;KAMY,wBAAwB,gCAEhC,wBAIO,mBAAmB,WAAW,gBAAgB,YAN7C,GAQD,YARC,CASF,kBATe,CASI,UATJ,CASe,CATf,CAAA,CAAA,UAAA,CAAA,EAS+B,SAT/B,CAAA,CAAA,EAAW,GAWzB,YAXyB,CAWZ,eAXY,CAWI,UAXJ,CAWe,CAXf,CAAA,CAAA,MAAA,CAAA,EAW2B,SAX3B,CAAA,CAAA,EAEhC,GAUO,kBAVP,CAU0B,UAV1B,CAUqC,CAVrC,CAAA,CAAA,QAAA,CAAA,EAUmD,SAVnD,CAAA,CAIqC,GAAA,KAAA;KAYpC,kBAZyB,CAAA,CAAA,EAAA,SAAA,EAAA,eAeb,KAfa,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAgB1B,CAhB0B,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAiB1B,kBAjB0B,CAkB1B,IAlB0B,EAmB1B,SAnB0B,EAAA,IAAA,SAoBb,SApBa,GAAA,CAAA,GAuBlB,MAvBkB,EAuBV,IAvBU,CAAA,GAwBtB,IAxBsB,GAwBf,SAxBe,SAAA,MAAA,GAiCpB,MAjCoB,GAkCpB,SAlCoB,SAAA,IAAA,GA0ClB,MA1CkB,GAAA,CAAA,GA0CL,MA1CK,EA0CG,SA1CH,CAAA,GA6ClB,MA7CkB,CAAA,GA+C1B,MA/C0B;KAmDzB,eAnDoD,CAAA,IAAA,EAAA,SAAA,CAAA,GAmDjB,IAnDiB,SAmDJ,SAnDI,GAoDrD,IApDqD,GAqDrD,SArDqD,SAqDnC,IArDmC,GAsDnD,SAtDmD,GAuDnD,kBAvDmD,CAuDhC,IAvDgC,EAuD1B,SAvD0B,CAAA;;;;;;;;;KAiEpD,kBA5D0D,CAAA,IAAA,EAAA,SAAA,CAAA,GA6D3D,IA7D2D,SA6D9C,MA7D8C,CA6DvC,WA7DuC,EAAA,OAAA,CAAA,GA8DzD,SA9DyD,SA8DvC,MA9DuC,CA8DhC,WA9DgC,EAAA,OAAA,CAAA,GAkEvD,OAlEuD,CAkE/C,OAlE+C,CAAA,MAkEjC,IAlEiC,EAAA,MAkErB,SAlEqB,CAAA,CAAA,SAAA,IAAA,GAAA,KAAA,GAoErD,IApEqD,GAoE9C,SApE8C,GAAA,KAAA,GAAA,KAAA"}

package/dist/filtered-array-wtIEwdU7.d.ts

@@ -0,0 +1,22 @@
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
+import { t as PartialArray } from "./partial-array-DU-2Vkyx.js";
+import { t as TupleParts } from "./tuple-parts-BYI4o8Vk.js";
+import { t as CoercedArray } from "./coerced-array-BfTLxqLo.js";
+import { IsNever } from "type-fest";
+
+//#region src/internal/types/filtered-array.d.ts
+type FilteredArray<T extends IterableContainer, Condition> = T extends unknown ? [...FilteredFixedTuple<TupleParts<T>['required'], Condition>, ...PartialArray<FilteredFixedTuple<TupleParts<T>['optional'], Condition>>, ...CoercedArray<SymmetricRefine<TupleParts<T>['item'], Condition>>, ...FilteredFixedTuple<TupleParts<T>['suffix'], Condition>] : never;
+type FilteredFixedTuple<T, Condition, Output extends Array<unknown> = []> = T extends readonly [infer Head, ...infer Rest] ? FilteredFixedTuple<Rest, Condition, Head extends Condition ? [...Output, Head] : Head | Condition extends object ? Output : Condition extends Head ? Output | [...Output, Condition] : Output> : Output;
+type SymmetricRefine<Item, Condition> = Item extends Condition ? Item : Condition extends Item ? Condition : RefineIncomparable<Item, Condition>;
+/**
+ * When types are incomparable (neither one extends the other) they might still
+ * have a common refinement; this can happen when two objects share one or more
+ * prop while both having distinct props too (e.g., `{ a: string; b: number }`
+ * and `{ b: number, c: boolean }`), or when a prop is wider in one of them,
+ * allowing more value types than the other (e.g.,
+ * `{ a: "cat" | "dog", b: number }` and `{ a: "cat" }`).
+ */
+type RefineIncomparable<Item, Condition> = Item extends Record<PropertyKey, unknown> ? Condition extends Record<PropertyKey, unknown> ? IsNever<Extract<keyof Item, keyof Condition>> extends true ? never : Item & Condition : never : never;
+//#endregion
+export { FilteredArray as t };
+//# sourceMappingURL=filtered-array-wtIEwdU7.d.ts.map

package/dist/filtered-array-wtIEwdU7.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filtered-array-wtIEwdU7.d.ts","names":[],"sources":["../src/internal/types/filtered-array.ts"],"sourcesContent":[],"mappings":";;;;;;;KAMY,wBAAwB,gCAEhC,wBAIO,mBAAmB,WAAW,gBAAgB,YAN7C,GAQD,YARC,CASF,kBATe,CASI,UATJ,CASe,CATf,CAAA,CAAA,UAAA,CAAA,EAS+B,SAT/B,CAAA,CAAA,EAAW,GAWzB,YAXyB,CAWZ,eAXY,CAWI,UAXJ,CAWe,CAXf,CAAA,CAAA,MAAA,CAAA,EAW2B,SAX3B,CAAA,CAAA,EAEhC,GAUO,kBAVP,CAU0B,UAV1B,CAUqC,CAVrC,CAAA,CAAA,QAAA,CAAA,EAUmD,SAVnD,CAAA,CAIqC,GAAA,KAAA;KAYpC,kBAZyB,CAAA,CAAA,EAAA,SAAA,EAAA,eAeb,KAfa,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAgB1B,CAhB0B,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAiB1B,kBAjB0B,CAkB1B,IAlB0B,EAmB1B,SAnB0B,EAAA,IAAA,SAoBb,SApBa,GAAA,CAAA,GAuBlB,MAvBkB,EAuBV,IAvBU,CAAA,GAwBtB,IAxBsB,GAwBf,SAxBe,SAAA,MAAA,GAiCpB,MAjCoB,GAkCpB,SAlCoB,SAAA,IAAA,GA0ClB,MA1CkB,GAAA,CAAA,GA0CL,MA1CK,EA0CG,SA1CH,CAAA,GA6ClB,MA7CkB,CAAA,GA+C1B,MA/C0B;KAmDzB,eAnDoD,CAAA,IAAA,EAAA,SAAA,CAAA,GAmDjB,IAnDiB,SAmDJ,SAnDI,GAoDrD,IApDqD,GAqDrD,SArDqD,SAqDnC,IArDmC,GAsDnD,SAtDmD,GAuDnD,kBAvDmD,CAuDhC,IAvDgC,EAuD1B,SAvD0B,CAAA;;;;;;;;;KAiEpD,kBA5D0D,CAAA,IAAA,EAAA,SAAA,CAAA,GA6D3D,IA7D2D,SA6D9C,MA7D8C,CA6DvC,WA7DuC,EAAA,OAAA,CAAA,GA8DzD,SA9DyD,SA8DvC,MA9DuC,CA8DhC,WA9DgC,EAAA,OAAA,CAAA,GAkEvD,OAlEuD,CAkE/C,OAlE+C,CAAA,MAkEjC,IAlEiC,EAAA,MAkErB,SAlEqB,CAAA,CAAA,SAAA,IAAA,GAAA,KAAA,GAoErD,IApEqD,GAoE9C,SApE8C,GAAA,KAAA,GAAA,KAAA"}

package/dist/find-index.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./find-index-CojMwOU1.cjs`);exports.findIndex=e.findIndex;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return e.findIndex(t)}exports.findIndex=t;

package/dist/find-index.d.cts

@@ -1,2 +1,50 @@
-import { findIndex } from "./find-index-mVR2WVAJ.cjs";
-export { findIndex };
+//#region src/find-index.d.ts
+/**
+ * Returns the index of the first element in an array that satisfies the
+ * provided testing function. If no elements satisfy the testing function, -1 is
+ * returned.
+ *
+ * See also the `find` method, which returns the first element that satisfies
+ * the testing function (rather than its index).
+ *
+ * @param data - The items to search in.
+ * @param predicate - A function to execute for each element in the array. It
+ * should return a `true` to indicate a matching element has been found, and a
+ * `false` otherwise.
+ * @returns The index of the first element in the array that passes the test.
+ * Otherwise, -1.
+ * @signature
+ *    P.findIndex(data, predicate)
+ * @example
+ *    P.findIndex([1, 3, 4, 6], n => n % 2 === 0) // => 2
+ * @dataFirst
+ * @category Array
+ */
+declare function findIndex<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): number;
+/**
+ * Returns the index of the first element in an array that satisfies the
+ * provided testing function. If no elements satisfy the testing function, -1 is
+ * returned.
+ *
+ * See also the `find` method, which returns the first element that satisfies
+ * the testing function (rather than its index).
+ *
+ * @param predicate - A function to execute for each element in the array. It
+ * should return a `true` to indicate a matching element has been found, and a
+ * `false` otherwise.
+ * @returns The index of the first element in the array that passes the test.
+ * Otherwise, -1.
+ * @signature
+ *    P.findIndex(predicate)(data)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findIndex(n => n % 2 === 0)
+ *    ); // => 2
+ * @dataLast
+ * @category Array
+ */
+declare function findIndex<T>(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => number;
+//#endregion
+export { findIndex };
+//# sourceMappingURL=find-index.d.cts.map

package/dist/find-index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-index.d.cts","names":[],"sources":["../src/find-index.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;;AA4BA;;;;;;;;;;;;;iBA5BgB,mBACR,cAAc,uBACD,uBAAuB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;iBA0B1C,gCACK,uBAAuB,cAAc,wBAChD,cAAc"}

package/dist/find-index.d.ts

@@ -1,2 +1,50 @@
-import { findIndex } from "./find-index-DlVnTeBV.js";
-export { findIndex };
+//#region src/find-index.d.ts
+/**
+ * Returns the index of the first element in an array that satisfies the
+ * provided testing function. If no elements satisfy the testing function, -1 is
+ * returned.
+ *
+ * See also the `find` method, which returns the first element that satisfies
+ * the testing function (rather than its index).
+ *
+ * @param data - The items to search in.
+ * @param predicate - A function to execute for each element in the array. It
+ * should return a `true` to indicate a matching element has been found, and a
+ * `false` otherwise.
+ * @returns The index of the first element in the array that passes the test.
+ * Otherwise, -1.
+ * @signature
+ *    P.findIndex(data, predicate)
+ * @example
+ *    P.findIndex([1, 3, 4, 6], n => n % 2 === 0) // => 2
+ * @dataFirst
+ * @category Array
+ */
+declare function findIndex<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): number;
+/**
+ * Returns the index of the first element in an array that satisfies the
+ * provided testing function. If no elements satisfy the testing function, -1 is
+ * returned.
+ *
+ * See also the `find` method, which returns the first element that satisfies
+ * the testing function (rather than its index).
+ *
+ * @param predicate - A function to execute for each element in the array. It
+ * should return a `true` to indicate a matching element has been found, and a
+ * `false` otherwise.
+ * @returns The index of the first element in the array that passes the test.
+ * Otherwise, -1.
+ * @signature
+ *    P.findIndex(predicate)(data)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findIndex(n => n % 2 === 0)
+ *    ); // => 2
+ * @dataLast
+ * @category Array
+ */
+declare function findIndex<T>(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => number;
+//#endregion
+export { findIndex };
+//# sourceMappingURL=find-index.d.ts.map

package/dist/find-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-index.d.ts","names":[],"sources":["../src/find-index.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;;AA4BA;;;;;;;;;;;;;iBA5BgB,mBACR,cAAc,uBACD,uBAAuB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;iBA0B1C,gCACK,uBAAuB,cAAc,wBAChD,cAAc"}

package/dist/find-index.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{findIndex as e}from"./find-index-CzHRd1Ey.js";export{e as findIndex};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return e.findIndex(t)}export{t as findIndex};
+//# sourceMappingURL=find-index.js.map

package/dist/find-index.js.map

@@ -0,0 +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 *    P.findIndex(data, predicate)\n * @example\n *    P.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 *    P.findIndex(predicate)(data)\n * @example\n *    P.pipe(\n *      [1, 3, 4, 6],\n *      P.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>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean,\n): number {\n  return data.findIndex(predicate);\n}\n"],"mappings":"wCAuDA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACQ,CACR,OAAO,EAAK,UAAU,EAAU"}

package/dist/find-last-index.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./find-last-index-C-wdKiKp.cjs`);exports.findLastIndex=e.findLastIndex;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(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;

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

@@ -1,2 +1,50 @@
-import { findLastIndex } from "./find-last-index-C4il48Y6.cjs";
-export { findLastIndex };
+//#region src/find-last-index.d.ts
+/**
+ * Iterates the array in reverse order and returns the index of the first
+ * element that satisfies the provided testing function. If no elements satisfy
+ * the testing function, -1 is returned.
+ *
+ * See also `findLast` which returns the value of last element that satisfies
+ * the testing function (rather than its index).
+ *
+ * @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.
+ * @returns The index of the last (highest-index) element in the array that
+ * passes the test. Otherwise -1 if no matching element is found.
+ * @signature
+ *    P.findLastIndex(data, predicate)
+ * @example
+ *    P.findLastIndex([1, 3, 4, 6], n => n % 2 === 1) // => 1
+ * @dataFirst
+ * @category Array
+ */
+declare function findLastIndex<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number;
+/**
+ * Iterates the array in reverse order and returns the index of the first
+ * element that satisfies the provided testing function. If no elements satisfy
+ * the testing function, -1 is returned.
+ *
+ * See also `findLast` which returns the value of last element that satisfies
+ * the testing function (rather than its index).
+ *
+ * @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.
+ * @returns The index of the last (highest-index) element in the array that
+ * passes the test. Otherwise -1 if no matching element is found.
+ * @signature
+ *    P.findLastIndex(fn)(items)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findLastIndex(n => n % 2 === 1)
+ *    ) // => 1
+ * @dataLast
+ * @category Array
+ */
+declare function findLastIndex<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (array: ReadonlyArray<T>) => number;
+//#endregion
+export { findLastIndex };
+//# sourceMappingURL=find-last-index.d.cts.map

package/dist/find-last-index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-last-index.d.cts","names":[],"sources":["../src/find-last-index.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;;AA4BA;;;;;;;;;;;;;iBA5BgB,uBACR,cAAc,uBACD,wBAAwB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;iBA0B3C,oCACK,wBAAwB,cAAc,yBAChD,cAAc"}

package/dist/find-last-index.d.ts

@@ -1,2 +1,50 @@
-import { findLastIndex } from "./find-last-index-DSUbOIoQ.js";
-export { findLastIndex };
+//#region src/find-last-index.d.ts
+/**
+ * Iterates the array in reverse order and returns the index of the first
+ * element that satisfies the provided testing function. If no elements satisfy
+ * the testing function, -1 is returned.
+ *
+ * See also `findLast` which returns the value of last element that satisfies
+ * the testing function (rather than its index).
+ *
+ * @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.
+ * @returns The index of the last (highest-index) element in the array that
+ * passes the test. Otherwise -1 if no matching element is found.
+ * @signature
+ *    P.findLastIndex(data, predicate)
+ * @example
+ *    P.findLastIndex([1, 3, 4, 6], n => n % 2 === 1) // => 1
+ * @dataFirst
+ * @category Array
+ */
+declare function findLastIndex<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): number;
+/**
+ * Iterates the array in reverse order and returns the index of the first
+ * element that satisfies the provided testing function. If no elements satisfy
+ * the testing function, -1 is returned.
+ *
+ * See also `findLast` which returns the value of last element that satisfies
+ * the testing function (rather than its index).
+ *
+ * @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.
+ * @returns The index of the last (highest-index) element in the array that
+ * passes the test. Otherwise -1 if no matching element is found.
+ * @signature
+ *    P.findLastIndex(fn)(items)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findLastIndex(n => n % 2 === 1)
+ *    ) // => 1
+ * @dataLast
+ * @category Array
+ */
+declare function findLastIndex<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (array: ReadonlyArray<T>) => number;
+//#endregion
+export { findLastIndex };
+//# sourceMappingURL=find-last-index.d.ts.map

package/dist/find-last-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-last-index.d.ts","names":[],"sources":["../src/find-last-index.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;;AA4BA;;;;;;;;;;;;;iBA5BgB,uBACR,cAAc,uBACD,wBAAwB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;iBA0B3C,oCACK,wBAAwB,cAAc,yBAChD,cAAc"}

package/dist/find-last-index.js

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

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

@@ -0,0 +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 *    P.findLastIndex(data, predicate)\n * @example\n *    P.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 *    P.findLastIndex(fn)(items)\n * @example\n *    P.pipe(\n *      [1, 3, 4, 6],\n *      P.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>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): number {\n  // TODO: 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":"wCAuDA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA6B,EAAK,CAGjD,SAAS,EACP,EACA,EACQ,CAGR,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,EAAU,EAAK,GAAK,EAAG,EAAK,CAC9B,OAAO,EAIX,MAAO"}

package/dist/find-last.cjs

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

package/dist/find-last.d.cts

@@ -1,2 +1,62 @@
-import { findLast } from "./find-last-DqGxSxQ-.cjs";
-export { findLast };
+//#region src/find-last.d.ts
+/**
+ * Iterates the array in reverse order and returns the value of the first
+ * element that satisfies the provided testing function. If no elements satisfy
+ * the testing function, undefined is returned.
+ *
+ * Similar functions:
+ * `find` - If you need the first element that satisfies the provided testing function.
+ * `findLastIndex` - If you need the index of the found element in the array.
+ * `lastIndexOf` - 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 last (highest-index) element in the array that satisfies the
+ * provided testing function; undefined if no matching element is found.
+ * @signature
+ *    P.findLast(data, predicate)
+ * @example
+ *    P.findLast([1, 3, 4, 6], n => n % 2 === 1) // => 3
+ * @dataFirst
+ * @category Array
+ */
+declare function findLast<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined;
+declare function findLast<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): T | undefined;
+/**
+ * Iterates the array in reverse order and returns the value of the first
+ * element that satisfies the provided testing function. If no elements satisfy
+ * the testing function, undefined is returned.
+ *
+ * Similar functions:
+ * `find` - If you need the first element that satisfies the provided testing function.
+ * `findLastIndex` - If you need the index of the found element in the array.
+ * `lastIndexOf` - 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 last (highest-index) element in the array that satisfies the
+ * provided testing function; undefined if no matching element is found.
+ * @signature
+ *    P.findLast(predicate)(data)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findLast(n => n % 2 === 1)
+ *    ) // => 3
+ * @dataLast
+ * @category Array
+ */
+declare function findLast<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => S | undefined;
+declare function findLast<T = never>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => T | undefined;
+//#endregion
+export { findLast };
+//# sourceMappingURL=find-last.d.cts.map

package/dist/find-last.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-last.d.cts","names":[],"sources":["../src/find-last.ts"],"sourcesContent":[],"mappings":";;AA4BA;;;;;;;;;;AAIA;;;;;;;;AAiCA;;;;;;;AAEU,iBAvCM,QAuCN,CAAA,CAAA,EAAA,UAvC4B,CAuC5B,CAAA,CAAA,IAAA,EAtCF,aAsCE,CAtCY,CAsCZ,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EArCW,CAqCX,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EArCmC,aAqCnC,CArCiD,CAqCjD,CAAA,EAAA,GAAA,KAAA,IArCiE,CAqCjE,CAAA,EApCP,CAoCO,GAAA,SAAA;AAAqB,iBAnCf,QAmCe,CAAA,CAAA,CAAA,CAAA,IAAA,EAlCvB,aAkCuB,CAlCT,CAkCS,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAjCV,CAiCU,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAjCc,aAiCd,CAjC4B,CAiC5B,CAAA,EAAA,GAAA,OAAA,CAAA,EAhC5B,CAgC4B,GAAA,SAAA;;AAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHgB,sBAAsB,sBACjB,wBAAwB,cAAc,gBAAgB,WACjE,cAAc,OAAO;iBACf,uCACK,wBAAwB,cAAc,wBACjD,cAAc,OAAO"}

package/dist/find-last.d.ts

@@ -1,2 +1,62 @@
-import { findLast } from "./find-last-Bd6eGQR1.js";
-export { findLast };
+//#region src/find-last.d.ts
+/**
+ * Iterates the array in reverse order and returns the value of the first
+ * element that satisfies the provided testing function. If no elements satisfy
+ * the testing function, undefined is returned.
+ *
+ * Similar functions:
+ * `find` - If you need the first element that satisfies the provided testing function.
+ * `findLastIndex` - If you need the index of the found element in the array.
+ * `lastIndexOf` - 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 last (highest-index) element in the array that satisfies the
+ * provided testing function; undefined if no matching element is found.
+ * @signature
+ *    P.findLast(data, predicate)
+ * @example
+ *    P.findLast([1, 3, 4, 6], n => n % 2 === 1) // => 3
+ * @dataFirst
+ * @category Array
+ */
+declare function findLast<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): S | undefined;
+declare function findLast<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): T | undefined;
+/**
+ * Iterates the array in reverse order and returns the value of the first
+ * element that satisfies the provided testing function. If no elements satisfy
+ * the testing function, undefined is returned.
+ *
+ * Similar functions:
+ * `find` - If you need the first element that satisfies the provided testing function.
+ * `findLastIndex` - If you need the index of the found element in the array.
+ * `lastIndexOf` - 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 last (highest-index) element in the array that satisfies the
+ * provided testing function; undefined if no matching element is found.
+ * @signature
+ *    P.findLast(predicate)(data)
+ * @example
+ *    P.pipe(
+ *      [1, 3, 4, 6],
+ *      P.findLast(n => n % 2 === 1)
+ *    ) // => 3
+ * @dataLast
+ * @category Array
+ */
+declare function findLast<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => S | undefined;
+declare function findLast<T = never>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => T | undefined;
+//#endregion
+export { findLast };
+//# sourceMappingURL=find-last.d.ts.map

package/dist/find-last.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-last.d.ts","names":[],"sources":["../src/find-last.ts"],"sourcesContent":[],"mappings":";;AA4BA;;;;;;;;;;AAIA;;;;;;;;AAiCA;;;;;;;AAEU,iBAvCM,QAuCN,CAAA,CAAA,EAAA,UAvC4B,CAuC5B,CAAA,CAAA,IAAA,EAtCF,aAsCE,CAtCY,CAsCZ,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EArCW,CAqCX,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EArCmC,aAqCnC,CArCiD,CAqCjD,CAAA,EAAA,GAAA,KAAA,IArCiE,CAqCjE,CAAA,EApCP,CAoCO,GAAA,SAAA;AAAqB,iBAnCf,QAmCe,CAAA,CAAA,CAAA,CAAA,IAAA,EAlCvB,aAkCuB,CAlCT,CAkCS,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAjCV,CAiCU,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAjCc,aAiCd,CAjC4B,CAiC5B,CAAA,EAAA,GAAA,OAAA,CAAA,EAhC5B,CAgC4B,GAAA,SAAA;;AAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHgB,sBAAsB,sBACjB,wBAAwB,cAAc,gBAAgB,WACjE,cAAc,OAAO;iBACf,uCACK,wBAAwB,cAAc,wBACjD,cAAc,OAAO"}

package/dist/find-last.js

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

package/dist/find-last.js.map

@@ -0,0 +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 *    P.findLast(data, predicate)\n * @example\n *    P.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 *    P.findLast(predicate)(data)\n * @example\n *    P.pipe(\n *      [1, 3, 4, 6],\n *      P.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>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): S | undefined {\n  // TODO: 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":"wCAwEA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EACe,CAGf,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IAAK,CACzC,IAAM,EAAO,EAAK,GAClB,GAAI,EAAU,EAAM,EAAG,EAAK,CAC1B,OAAO"}

package/dist/find.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./utility-evaluators-DqJcWENu.cjs`),require(`./to-single-Bnq9l8Zp.cjs`);const e=require(`./find-BuO4hH8Z.cjs`);exports.find=e.find;
+const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./utility-evaluators-CAbODbuk.cjs`),n=require(`./to-single-Chq_hKEk.cjs`);function r(...t){return e.t(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;