@vinicunca/perkakas 1.7.1 → 1.9.0

package/dist/evolve.d.cts

@@ -1,102 +1,3 @@
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
-
-/**
- * Creates an assumed `evolver` type from the type of `data` argument.
- *
- * @example
- * interface Data {
- *   id: number;
- *   quartile: Array<number>;
- *   time?: { elapsed: number; remaining?: number };
- * }
- * type Nested = Evolver<Data>; //  => type Nested = {
- * //   id?: ((data: number) => unknown) | undefined;
- * //   quartile?: ((data: number[]) => unknown) | undefined;
- * //   time?:
- * //     | ((data: { elapsed: number; remaining?: number | undefined }) => unknown)
- * //     | {
- * //         elapsed?: ((data: number) => unknown) | undefined;
- * //         remaining?: ((data: number) => unknown) | undefined;
- * //       }
- * //     | undefined;
- * // };
- */
-type Evolver<T> = T extends object ? T extends IterableContainer ? never : {
-    readonly [K in keyof T]?: K extends symbol ? never : ((data: Required<T>[K]) => unknown) | Evolver<T[K]>;
-} : never;
-/**
- * Creates return type from the type of arguments of `evolve`.
- */
-type Evolved<T, E> = T extends object ? {
-    -readonly [K in keyof T]: K extends keyof E ? E[K] extends (...arg: any) => infer R ? R : Evolved<T[K], E[K]> : Required<T>[K];
-} : T;
-/**
- * Creates a new object by applying functions that is included in `evolver` object parameter
- * to the `data` object parameter according to their corresponding path.
- *
- * Functions included in `evolver` object will not be invoked
- * if its corresponding key does not exist in the `data` object.
- * Also, values included in `data` object will be kept as is
- * if its corresponding key does not exist in the `evolver` object.
- *
- * @param object - Object whose value is applied to the corresponding function
- * that is defined in `evolver` at the same path.
- * @param evolver - Object that include functions that is applied to
- * the corresponding value of `data` object at the same path.
- * @signature
- *    P.evolve(data, evolver)
- * @example
- *    const evolver = {
- *      count: add(1),
- *      time: { elapsed: add(1), remaining: add(-1) },
- *    };
- *    const data = {
- *      id: 10,
- *      count: 10,
- *      time: { elapsed: 100, remaining: 1400 },
- *    };
- *    evolve(data, evolver)
- *    // => {
- *    //   id: 10,
- *    //   count: 11,
- *    //   time: { elapsed: 101, remaining: 1399 },
- *    // }
- * @dataFirst
- * @category Object
- */
-declare function evolve<T extends object, E extends Evolver<T>>(object: T, evolver: E): Evolved<T, E>;
-/**
- * Creates a new object by applying functions that is included in `evolver` object parameter
- * to the `data` object parameter according to their corresponding path.
- *
- * Functions included in `evolver` object will not be invoked
- * if its corresponding key does not exist in the `data` object.
- * Also, values included in `data` object will not be used
- * if its corresponding key does not exist in the `evolver` object.
- *
- * @param evolver - Object that include functions that is applied to
- * the corresponding value of `data` object at the same path.
- * @signature
- *    P.evolve(evolver)(data)
- * @example
- *    const evolver = {
- *      count: add(1),
- *      time: { elapsed: add(1), remaining: add(-1) },
- *    };
- *    const data = {
- *      id: 10,
- *      count: 10,
- *      time: { elapsed: 100, remaining: 1400 },
- *    };
- *    P.pipe(object, P.evolve(evolver))
- *    // => {
- *    //   id: 10,
- *    //   count: 11,
- *    //   time: { elapsed: 101, remaining: 1399 },
- *    // }
- * @dataLast
- * @category Object
- */
-declare function evolve<T extends object, E extends Evolver<T>>(evolver: E): (object: T) => Evolved<T, E>;
-
-export { evolve };
+import "./iterable-container-V5sa0V_H.cjs";
+import { evolve } from "./evolve-DOxUNkYX.cjs";
+export { evolve };

package/dist/evolve.d.ts

@@ -1,102 +1,3 @@
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
-
-/**
- * Creates an assumed `evolver` type from the type of `data` argument.
- *
- * @example
- * interface Data {
- *   id: number;
- *   quartile: Array<number>;
- *   time?: { elapsed: number; remaining?: number };
- * }
- * type Nested = Evolver<Data>; //  => type Nested = {
- * //   id?: ((data: number) => unknown) | undefined;
- * //   quartile?: ((data: number[]) => unknown) | undefined;
- * //   time?:
- * //     | ((data: { elapsed: number; remaining?: number | undefined }) => unknown)
- * //     | {
- * //         elapsed?: ((data: number) => unknown) | undefined;
- * //         remaining?: ((data: number) => unknown) | undefined;
- * //       }
- * //     | undefined;
- * // };
- */
-type Evolver<T> = T extends object ? T extends IterableContainer ? never : {
-    readonly [K in keyof T]?: K extends symbol ? never : ((data: Required<T>[K]) => unknown) | Evolver<T[K]>;
-} : never;
-/**
- * Creates return type from the type of arguments of `evolve`.
- */
-type Evolved<T, E> = T extends object ? {
-    -readonly [K in keyof T]: K extends keyof E ? E[K] extends (...arg: any) => infer R ? R : Evolved<T[K], E[K]> : Required<T>[K];
-} : T;
-/**
- * Creates a new object by applying functions that is included in `evolver` object parameter
- * to the `data` object parameter according to their corresponding path.
- *
- * Functions included in `evolver` object will not be invoked
- * if its corresponding key does not exist in the `data` object.
- * Also, values included in `data` object will be kept as is
- * if its corresponding key does not exist in the `evolver` object.
- *
- * @param object - Object whose value is applied to the corresponding function
- * that is defined in `evolver` at the same path.
- * @param evolver - Object that include functions that is applied to
- * the corresponding value of `data` object at the same path.
- * @signature
- *    P.evolve(data, evolver)
- * @example
- *    const evolver = {
- *      count: add(1),
- *      time: { elapsed: add(1), remaining: add(-1) },
- *    };
- *    const data = {
- *      id: 10,
- *      count: 10,
- *      time: { elapsed: 100, remaining: 1400 },
- *    };
- *    evolve(data, evolver)
- *    // => {
- *    //   id: 10,
- *    //   count: 11,
- *    //   time: { elapsed: 101, remaining: 1399 },
- *    // }
- * @dataFirst
- * @category Object
- */
-declare function evolve<T extends object, E extends Evolver<T>>(object: T, evolver: E): Evolved<T, E>;
-/**
- * Creates a new object by applying functions that is included in `evolver` object parameter
- * to the `data` object parameter according to their corresponding path.
- *
- * Functions included in `evolver` object will not be invoked
- * if its corresponding key does not exist in the `data` object.
- * Also, values included in `data` object will not be used
- * if its corresponding key does not exist in the `evolver` object.
- *
- * @param evolver - Object that include functions that is applied to
- * the corresponding value of `data` object at the same path.
- * @signature
- *    P.evolve(evolver)(data)
- * @example
- *    const evolver = {
- *      count: add(1),
- *      time: { elapsed: add(1), remaining: add(-1) },
- *    };
- *    const data = {
- *      id: 10,
- *      count: 10,
- *      time: { elapsed: 100, remaining: 1400 },
- *    };
- *    P.pipe(object, P.evolve(evolver))
- *    // => {
- *    //   id: 10,
- *    //   count: 11,
- *    //   time: { elapsed: 101, remaining: 1399 },
- *    // }
- * @dataLast
- * @category Object
- */
-declare function evolve<T extends object, E extends Evolver<T>>(evolver: E): (object: T) => Evolved<T, E>;
-
-export { evolve };
+import "./iterable-container-F9CDF7ym.js";
+import { evolve } from "./evolve-3KidXCB8.js";
+export { evolve };

package/dist/evolve.js

@@ -1 +1 @@
-import{a}from"./chunk-EFMVPY3K.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as evolve};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{evolve as e}from"./evolve-BReerpSa.js";export{e as evolve};

package/dist/filter-Bg-TEmtZ.d.ts

@@ -0,0 +1,50 @@
+import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
+import { FilteredArray } from "./filtered-array-CPOk8m8s.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-Bg-TEmtZ.d.ts.map

package/dist/filter-Bg-TEmtZ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-Bg-TEmtZ.d.ts","names":[],"sources":["../src/filter.ts"],"sourcesContent":[],"mappings":";;;;;KAWK,kCACO,qEAEQ,iBAKhB,MAAM,aACN,8BAGE,SAAS;;AArB8D;;;;;;;;;;AA4C7E;;;;;;;;AAMiB,iBAND,MAMC,CAAA,UALL,iBAKK,EAAA,kBAJG,CAIH,CAAA,MAAA,CAAA,CAAA,CAAA,IAAA,EAFT,CAES,EAAA,SAAA,EAAA,CAAA,KAAA,EADI,CACJ,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADoC,CACpC,EAAA,GAAA,KAAA,IADmD,SACnD,CAAA,EAAd,aAAc,CAAA,CAAA,EAAG,SAAH,CAAA;AAAG,iBACJ,MADI,CAAA,UAER,iBAFQ,EAAA,uBAAA,OAAA,CAAA,CAAA,IAAA,EAKZ,CALY,EAAA,SAAA,EAAA,CAAA,KAAA,EAMC,CAND,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAMiC,CANjC,EAAA,GAMuC,cANvC,CAAA,EAOjB,uBAPiB,CAOO,CAPP,EAOU,cAPV,CAAA;;;AACpB;;;;;;;;;;;AA0BA;;;;;AAIqD,iBAJrC,MAIqC,CAAA,UAHzC,iBAGyC,EAAA,kBAFjC,CAEiC,CAAA,MAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAAhC,CAAgC,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAAA,CAAA,EAAA,GAAA,KAAA,IAAe,SAAf,CAAA,EAAA,CAAA,IAAA,EAC3C,CAD2C,EAAA,GACrC,aADqC,CACvB,CADuB,EACpB,SADoB,CAAA;AAAe,iBAEpD,MAFoD,CAAA,UAGxD,iBAHwD,EAAA,uBAAA,OAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAM/C,CAN+C,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAMf,CANe,EAAA,GAMT,cANS,CAAA,EAAA,CAAA,IAAA,EAO1D,CAP0D,EAAA,GAOpD,uBAPoD,CAO5B,CAP4B,EAOzB,cAPyB,CAAA"}

package/dist/filter-CH_YQe9A.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";import{SKIP_ITEM as t}from"./utility-evaluators-CnQVdcZv.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-CH_YQe9A.js.map

package/dist/filter-CH_YQe9A.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-CH_YQe9A.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":"yGA4FA,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/filter-CkFzFT5Q.d.cts

@@ -0,0 +1,50 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+import { FilteredArray } from "./filtered-array-DQcAXQDD.cjs";
+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-CkFzFT5Q.d.cts.map

package/dist/filter-CkFzFT5Q.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-CkFzFT5Q.d.cts","names":[],"sources":["../src/filter.ts"],"sourcesContent":[],"mappings":";;;;;KAWK,kCACO,qEAEQ,iBAKhB,MAAM,aACN,8BAGE,SAAS;;AArB8D;;;;;;;;;;AA4C7E;;;;;;;;AAMiB,iBAND,MAMC,CAAA,UALL,iBAKK,EAAA,kBAJG,CAIH,CAAA,MAAA,CAAA,CAAA,CAAA,IAAA,EAFT,CAES,EAAA,SAAA,EAAA,CAAA,KAAA,EADI,CACJ,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADoC,CACpC,EAAA,GAAA,KAAA,IADmD,SACnD,CAAA,EAAd,aAAc,CAAA,CAAA,EAAG,SAAH,CAAA;AAAG,iBACJ,MADI,CAAA,UAER,iBAFQ,EAAA,uBAAA,OAAA,CAAA,CAAA,IAAA,EAKZ,CALY,EAAA,SAAA,EAAA,CAAA,KAAA,EAMC,CAND,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAMiC,CANjC,EAAA,GAMuC,cANvC,CAAA,EAOjB,uBAPiB,CAOO,CAPP,EAOU,cAPV,CAAA;;;AACpB;;;;;;;;;;;AA0BA;;;;;AAIqD,iBAJrC,MAIqC,CAAA,UAHzC,iBAGyC,EAAA,kBAFjC,CAEiC,CAAA,MAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAAhC,CAAgC,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAAA,CAAA,EAAA,GAAA,KAAA,IAAe,SAAf,CAAA,EAAA,CAAA,IAAA,EAC3C,CAD2C,EAAA,GACrC,aADqC,CACvB,CADuB,EACpB,SADoB,CAAA;AAAe,iBAEpD,MAFoD,CAAA,UAGxD,iBAHwD,EAAA,uBAAA,OAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAM/C,CAN+C,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAMf,CANe,EAAA,GAMT,cANS,CAAA,EAAA,CAAA,IAAA,EAO1D,CAP0D,EAAA,GAOpD,uBAPoD,CAO5B,CAP4B,EAOzB,cAPyB,CAAA"}

package/dist/filter-DsjklegV.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`),t=require(`./utility-evaluators-DqJcWENu.cjs`);function n(...t){return e.curry(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.SKIP_ITEM}Object.defineProperty(exports,`filter`,{enumerable:!0,get:function(){return n}});

package/dist/filter.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk3LC3CLYEcjs = require('./chunk-3LC3CLYE.cjs');require('./chunk-N5JE6642.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.filter = _chunk3LC3CLYEcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./utility-evaluators-DqJcWENu.cjs`);const e=require(`./filter-DsjklegV.cjs`);exports.filter=e.filter;

package/dist/filter.d.cts

@@ -1,51 +1,7 @@
-import { Writable } from 'type-fest';
-import { F as FilteredArray } from './filtered-array-BCjySbC6.cjs';
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
-import './coerced-array-DRz3tqda.cjs';
-import './tuple-parts-v6av7LMU.cjs';
-import './perkakas-type-error-8wPb8T2y.cjs';
-
-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>;
-
-export { filter };
+import "./iterable-container-V5sa0V_H.cjs";
+import "./perkakas-type-error-0tHtaPbi.cjs";
+import "./tuple-parts-BIyABPYv.cjs";
+import "./coerced-array-kVJtBrMl.cjs";
+import "./filtered-array-DQcAXQDD.cjs";
+import { filter } from "./filter-CkFzFT5Q.cjs";
+export { filter };

package/dist/filter.d.ts

@@ -1,51 +1,7 @@
-import { Writable } from 'type-fest';
-import { F as FilteredArray } from './filtered-array-JKATL39M.js';
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
-import './coerced-array-DRz3tqda.js';
-import './tuple-parts-BTivqbtT.js';
-import './perkakas-type-error-8wPb8T2y.js';
-
-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>;
-
-export { filter };
+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 };

package/dist/filter.js

@@ -1 +1 @@
-import{a}from"./chunk-ZITGCTSW.js";import"./chunk-EPU4K3DD.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as filter};
+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};

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

@@ -0,0 +1,13 @@
+import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
+import { TupleParts } from "./tuple-parts-Du2iVN8H.js";
+import { CoercedArray } from "./coerced-array-Fezc8pIu.js";
+
+//#region src/internal/types/filtered-array.d.ts
+type FilteredArray<T extends IterableContainer, Condition> = T extends unknown ? [...FilteredFixedTuple<TupleParts<T>['required'], Condition>, ...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 ?
+// But for any other type (mostly primitives), if the condition
+Output | [...Output, Condition] : Output> : Output;
+type SymmetricRefine<Item, Condition> = Item extends Condition ? Item : Condition extends Item ? Condition : never;
+//#endregion
+export { FilteredArray };
+//# sourceMappingURL=filtered-array-CPOk8m8s.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filtered-array-CPOk8m8s.d.ts","names":[],"sources":["../src/internal/types/filtered-array.ts"],"sourcesContent":[],"mappings":";;;;;KAIY,wBAAwB,gCAEhC,wBAIO,mBAAmB,WAAW,gBAAgB,YAN7C,GAYD,kBAZc,CAYK,UAZL,CAYgB,CAZhB,CAAA,CAAA,UAAA,CAAA,EAYgC,SAZhC,CAAA,EAAA,GAcd,YAdc,CAcD,eAdC,CAce,UAdf,CAc0B,CAd1B,CAAA,CAAA,MAAA,CAAA,EAcsC,SAdtC,CAAA,CAAA,KAed,kBAfyB,CAeN,UAfM,CAeK,CAfL,CAAA,CAAA,QAAA,CAAA,EAemB,SAfnB,CAAA,SAEhC;KAmBC,kBAfoC,CAAA,CAAA,EAAA,SAAA,EAAA,eAkBxB,KAlBwB,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAmBrC,CAnBqC,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAoBrC,kBApBqC,CAqBrC,IArBqC,EAsBrC,SAtBqC,EAuBrC,IAvBqC,SAuBxB,SAvBwB,GAAA,IA0B7B,MA1BkB,EA0BV,IA1BqC,IA2BjD,IA3BG,GA2BI,SA3BJ,SAAA,MAAA,GAoCH,MApCG,GAqCD,SArCC,SAqCiB,IArCjB;AAAA;AA6CG,SAvC2B,CAAA,GAuCd,MAvCc,EAuCN,SAvCM,CAAA,GA0C/B,MA1C+B,CAAA,GA4CrC,MA5CqC;KAgDpC,eAhDyB,CAAA,IAAA,EAAA,SAAA,CAAA,GAgDU,IAhDV,SAgDuB,SAhDvB,GAiD1B,IAjD0B,GAkD1B,SAlD0B,SAkDR,IAlDQ,GAmDxB,SAnDwB,GAAA,KAAA"}

package/dist/filtered-array-DQcAXQDD.d.cts

@@ -0,0 +1,13 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+import { TupleParts } from "./tuple-parts-BIyABPYv.cjs";
+import { CoercedArray } from "./coerced-array-kVJtBrMl.cjs";
+
+//#region src/internal/types/filtered-array.d.ts
+type FilteredArray<T extends IterableContainer, Condition> = T extends unknown ? [...FilteredFixedTuple<TupleParts<T>['required'], Condition>, ...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 ?
+// But for any other type (mostly primitives), if the condition
+Output | [...Output, Condition] : Output> : Output;
+type SymmetricRefine<Item, Condition> = Item extends Condition ? Item : Condition extends Item ? Condition : never;
+//#endregion
+export { FilteredArray };
+//# sourceMappingURL=filtered-array-DQcAXQDD.d.cts.map

package/dist/filtered-array-DQcAXQDD.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filtered-array-DQcAXQDD.d.cts","names":[],"sources":["../src/internal/types/filtered-array.ts"],"sourcesContent":[],"mappings":";;;;;KAIY,wBAAwB,gCAEhC,wBAIO,mBAAmB,WAAW,gBAAgB,YAN7C,GAYD,kBAZc,CAYK,UAZL,CAYgB,CAZhB,CAAA,CAAA,UAAA,CAAA,EAYgC,SAZhC,CAAA,EAAA,GAcd,YAdc,CAcD,eAdC,CAce,UAdf,CAc0B,CAd1B,CAAA,CAAA,MAAA,CAAA,EAcsC,SAdtC,CAAA,CAAA,KAed,kBAfyB,CAeN,UAfM,CAeK,CAfL,CAAA,CAAA,QAAA,CAAA,EAemB,SAfnB,CAAA,SAEhC;KAmBC,kBAfoC,CAAA,CAAA,EAAA,SAAA,EAAA,eAkBxB,KAlBwB,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAmBrC,CAnBqC,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAoBrC,kBApBqC,CAqBrC,IArBqC,EAsBrC,SAtBqC,EAuBrC,IAvBqC,SAuBxB,SAvBwB,GAAA,IA0B7B,MA1BkB,EA0BV,IA1BqC,IA2BjD,IA3BG,GA2BI,SA3BJ,SAAA,MAAA,GAoCH,MApCG,GAqCD,SArCC,SAqCiB,IArCjB;AAAA;AA6CG,SAvC2B,CAAA,GAuCd,MAvCc,EAuCN,SAvCM,CAAA,GA0C/B,MA1C+B,CAAA,GA4CrC,MA5CqC;KAgDpC,eAhDyB,CAAA,IAAA,EAAA,SAAA,CAAA,GAgDU,IAhDV,SAgDuB,SAhDvB,GAiD1B,IAjD0B,GAkD1B,SAlD0B,SAkDR,IAlDQ,GAmDxB,SAnDwB,GAAA,KAAA"}

package/dist/find-Bc-wGZYR.d.cts

@@ -0,0 +1,64 @@
+//#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-Bc-wGZYR.d.cts.map

package/dist/find-Bc-wGZYR.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-Bc-wGZYR.d.cts","names":[],"sources":["../src/find.ts"],"sourcesContent":[],"mappings":";;AAgCA;;;;;;;;;;;AAIA;;;;;;;;;AAkCA;;;;;;AAC2E,iBAvC3D,IAuC2D,CAAA,CAAA,EAAA,UAvCzC,CAuCyC,CAAA,CAAA,IAAA,EAtCnE,aAsCmE,CAtCrD,CAsCqD,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EArCtD,CAqCsD,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EArC9B,aAqC8B,CArChB,CAqCgB,CAAA,EAAA,GAAA,KAAA,IArCA,CAqCA,CAAA,EApCxE,CAoCwE,GAAA,SAAA;AACnD,iBApCR,IAoCQ,CAAA,CAAA,CAAA,CAAA,IAAA,EAnChB,aAmCgB,CAnCF,CAmCE,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAlCH,CAkCG,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAlCqB,aAkCrB,CAlCmC,CAkCnC,CAAA,EAAA,GAAA,OAAA,CAAA,EAjCrB,CAiCqB,GAAA,SAAA;;;;AACxB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHgB,kBAAkB,sBACb,wBAAwB,cAAc,gBAAgB,WACjE,cAAc,OAAO;iBACf,2BACK,wBAAwB,cAAc,wBACjD,cAAc,OAAO"}

package/dist/find-BuO4hH8Z.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`),t=require(`./utility-evaluators-DqJcWENu.cjs`),n=require(`./to-single-Bnq9l8Zp.cjs`);function r(...t){return e.curry(i,t,n.toSingle(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.SKIP_ITEM}Object.defineProperty(exports,`find`,{enumerable:!0,get:function(){return r}});

package/dist/find-DR6lM3gh.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";import{SKIP_ITEM as t}from"./utility-evaluators-CnQVdcZv.js";import{toSingle as n}from"./to-single-bHVECPzX.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-DR6lM3gh.js.map

package/dist/find-DR6lM3gh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-DR6lM3gh.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":"4JA6EA,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"}