@vinicunca/perkakas 0.4.1 → 0.4.3

package/dist/types/array/uniq-by.d.ts

@@ -1,22 +0,0 @@
-export declare function uniqBy<T, K>(array: ReadonlyArray<T>, transformer: (item: T) => K): Array<T>;
-/**
- * Returns a new array containing only one copy of each element in the original list transformed by a function.
- * Elements are compared by reference using Set.
- * @param array
- * @signature
- *    P.uniqBy(array, fn)
- * @example
- *    P.uniqBy(
- *     [{ n: 1 }, { n: 2 }, { n: 2 }, { n: 5 }, { n: 1 }, { n: 6 }, { n: 7 }],
- *     (obj) => obj.n,
- *    ) // => [{n: 1}, {n: 2}, {n: 5}, {n: 6}, {n: 7}]
- *    P.pipe(
- *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations
- *      P.uniqBy(obj => obj.n),
- *      P.take(3)
- *    ) // => [{n: 1}, {n: 2}, {n: 5}]
- * @pipeable
- * @category Array
- */
-export declare function uniqBy<T, K>(transformer: (item: T) => K): (array: ReadonlyArray<T>) => Array<T>;
-//# sourceMappingURL=uniq-by.d.ts.map

package/dist/types/array/uniq-by.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"uniq-by.d.ts","sourceRoot":"","sources":["../../../src/array/uniq-by.ts"],"names":[],"mappings":"AAKA,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAC1B,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;;;GAkBG;AAEH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAC1B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/uniq-with.d.ts

@@ -1,44 +0,0 @@
-import type { LazyEvaluator } from '../function/pipe';
-type IsEquals<T> = (a: T, b: T) => boolean;
-/**
- * Returns a new array containing only one copy of each element in the original list.
- * Elements are compared by custom comparator isEquals.
- * @param array
- * @param isEquals the comparator
- * @signature
- *    P.uniqWith(array, isEquals)
- * @example
- *    P.uniqWith(
- *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],
- *      P.isDeepEqual,
- *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]
- * @dataFirst
- * @category Array
- */
-export declare function uniqWith<T>(array: ReadonlyArray<T>, isEquals: IsEquals<T>): Array<T>;
-/**
- * Returns a new array containing only one copy of each element in the original list.
- * Elements are compared by custom comparator isEquals.
- * @param isEquals the comparator
- * @signature P.uniqWith(isEquals)(array)
- * @example
- *    P.uniqWith(P.isDeepEqual)(
- *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],
- *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]
- *    P.pipe(
- *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}], // only 4 iterations
- *      P.uniqWith(P.isDeepEqual),
- *      P.take(3)
- *    ) // => [{a: 1}, {a: 2}, {a: 5}]
- * @dataLast
- * @category Object
- */
-export declare function uniqWith<T>(isEquals: IsEquals<T>): (array: ReadonlyArray<T>) => Array<T>;
-declare function lazy_<T>(isEquals: IsEquals<T>): LazyEvaluator<T>;
-export declare namespace uniqWith {
-    const lazy: typeof lazy_ & {
-        readonly indexed: true;
-    };
-}
-export {};
-//# sourceMappingURL=uniq-with.d.ts.map

package/dist/types/array/uniq-with.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"uniq-with.d.ts","sourceRoot":"","sources":["../../../src/array/uniq-with.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAMtD,KAAK,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;AAE3C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GACpB,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GACpB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAczC,iBAAS,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAMzD;AAED,yBAAiB,QAAQ,CAAC;IACjB,MAAM,IAAI;;KAAuB,CAAC;CAC1C"}

package/dist/types/array/uniq.d.ts

@@ -1,35 +0,0 @@
-import type { LazyEvaluator } from '../function/pipe';
-/**
- * Returns a new array containing only one copy of each element in the original list.
- * Elements are compared by reference using Set.
- * @param array
- * @signature
- *    P.uniq(array)
- * @example
- *    P.uniq([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]
- * @pipeable
- * @category Array
- * @dataFirst
- */
-export declare function uniq<T>(array: ReadonlyArray<T>): Array<T>;
-/**
- * Returns a new array containing only one copy of each element in the original list.
- * Elements are compared by reference using Set.
- * @param array
- * @signature
- *    P.uniq()(array)
- * @example
- *    P.pipe(
- *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations
- *      P.uniq(),
- *      P.take(3)
- *    ) // => [1, 2, 5]
- * @pipeable
- * @category Array
- * @dataLast
- */
-export declare function uniq<T>(): (array: ReadonlyArray<T>) => Array<T>;
-export declare namespace uniq {
-    function lazy<T>(): LazyEvaluator<T>;
-}
-//# sourceMappingURL=uniq.d.ts.map

package/dist/types/array/uniq.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"uniq.d.ts","sourceRoot":"","sources":["../../../src/array/uniq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKtD;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAUjE,yBAAiB,IAAI,CAAC;IACpB,SAAgB,IAAI,CAAC,CAAC,KAAK,aAAa,CAAC,CAAC,CAAC,CAS1C;CACF"}

package/dist/types/array/zip-obj.d.ts

@@ -1,26 +0,0 @@
-/**
- * Creates a new object from two supplied lists by pairing up equally-positioned items.
- * Key/value pairing is truncated to the length of the shorter of the two lists
- * @param first the first input list
- * @param second the second input list
- * @signature
- *   P.zipObj(first, second)
- * @example
- *   P.zipObj(['a', 'b'], [1, 2]) // => {a: 1, b: 2}
- * @dataFirst
- * @category Array
- */
-export declare function zipObj<F extends PropertyKey, S>(first: ReadonlyArray<F>, second: ReadonlyArray<S>): Record<F, S>;
-/**
- * Creates a new object from two supplied lists by pairing up equally-positioned items.
- * Key/value pairing is truncated to the length of the shorter of the two lists
- * @param second the second input list
- * @signature
- *   P.zipObj(second)(first)
- * @example
- *   P.zipObj([1, 2])(['a', 'b']) // => {a: 1, b: 2}
- * @dataLast
- * @category Array
- */
-export declare function zipObj<S>(second: ReadonlyArray<S>): <F extends PropertyKey>(first: ReadonlyArray<F>) => Record<F, S>;
-//# sourceMappingURL=zip-obj.d.ts.map

package/dist/types/array/zip-obj.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zip-obj.d.ts","sourceRoot":"","sources":["../../../src/array/zip-obj.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,EAC7C,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GACvB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEhB;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GACvB,CAAC,CAAC,SAAS,WAAW,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/types/array/zip-with.d.ts

@@ -1,42 +0,0 @@
-type ZippingFunction<F = unknown, S = unknown, R = unknown> = (f: F, s: S) => R;
-/**
- * Creates a new list from two supplied lists by calling the supplied function
- * with the same-positioned element from each list.
- * @param first the first input list
- * @param second the second input list
- * @param fn the function applied to each position of the list
- * @signature
- *   P.zipWith(first, second, fn)
- * @example
- *   P.zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']
- * @dataFirst
- * @category Array
- */
-export declare function zipWith<F, S, R>(first: ReadonlyArray<F>, second: ReadonlyArray<S>, fn: ZippingFunction<F, S, R>): Array<R>;
-/**
- * Creates a new list from two supplied lists by calling the supplied function
- * with the same-positioned element from each list.
- * @param fn the function applied to each position of the list
- * @signature
- *   P.zipWith(fn)(first, second)
- * @example
- *   P.zipWith((a, b) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']
- * @dataLast
- * @category Array
- */
-export declare function zipWith<F, S, R>(fn: ZippingFunction<F, S, R>): (first: ReadonlyArray<F>, second: ReadonlyArray<S>) => Array<R>;
-/**
- * Creates a new list from two supplied lists by calling the supplied function
- * with the same-positioned element from each list.
- * @param fn the function applied to each position of the list
- * @param second the second input list
- * @signature
- *   P.zipWith(fn)(first, second)
- * @example
- *   P.zipWith((a, b) => a + b, ['a', 'b', 'c'])(['1', '2', '3']) // => ['1a', '2b', '3c']
- * @dataLast
- * @category Array
- */
-export declare function zipWith<F, S, R>(fn: ZippingFunction<F, S, R>, second: ReadonlyArray<S>): (first: ReadonlyArray<F>) => Array<R>;
-export {};
-//# sourceMappingURL=zip-with.d.ts.map

package/dist/types/array/zip-with.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zip-with.d.ts","sourceRoot":"","sources":["../../../src/array/zip-with.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;AAEhF;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EACxB,EAAE,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAC3B,KAAK,CAAC,CAAC,CAAC,CAAC;AAEZ;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,EAAE,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAC3B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7B,EAAE,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC5B,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GACvB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/array/zip.d.ts

@@ -1,52 +0,0 @@
-import type { IterableContainer } from '../utils/types';
-/**
- * Creates a new list from two supplied lists by pairing up equally-positioned items.
- * The length of the returned list will match the shortest of the two inputs.
- *
- * If the input array are tuples, you can use the strict option
- * to get another tuple instead of a generic array type.
- * @param first the first input list
- * @param second the second input list
- * @signature
- *   P.zip(first, second)
- * @example
- *   P.zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']] (type: [number, string][])
- *   P.zip.strict([1, 2] as const, ['a', 'b'] as const) // => [[1, 'a'], [2, 'b']]  (type: [[1, 'a'], [2, 'b']])
- * @dataFirst
- * @category Array
- * @strict
- */
-export declare function zip<F, S>(first: ReadonlyArray<F>, second: ReadonlyArray<S>): Array<[F, S]>;
-/**
- * Creates a new list from two supplied lists by pairing up equally-positioned items.
- * The length of the returned list will match the shortest of the two inputs.
- *
- * If the input array are tuples, you can use the strict option
- * to get another tuple instead of a generic array type.
- * @param second the second input list
- * @signature
- *   P.zip(second)(first)
- * @example
- *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']] (type: [number, string][])
- *   P.zip.strict(['a', 'b'] as const)([1, 2] as const) // => [[1, 'a'], [2, 'b']]  (type: [[1, 'a'], [2, 'b']])
- * @dataLast
- * @category Array
- * @strict
- */
-export declare function zip<S>(second: ReadonlyArray<S>): <F>(first: ReadonlyArray<F>) => Array<[F, S]>;
-interface Strict {
-    <F extends IterableContainer, S extends IterableContainer>(first: F, second: S): Zip<F, S>;
-    <S extends IterableContainer>(second: S): <F extends IterableContainer>(first: F) => Zip<F, S>;
-}
-type Zip<Left extends IterableContainer, Right extends IterableContainer> = Left extends readonly [] ? [] : Right extends readonly [] ? [] : Left extends readonly [infer LeftHead, ...infer LeftRest] ? Right extends readonly [infer RightHead, ...infer RightRest] ? [
-    [LeftHead, RightHead],
-    ...Zip<LeftRest, RightRest>
-] : [
-    [LeftHead, Right[number]],
-    ...Zip<LeftRest, Right>
-] : Right extends readonly [infer RightHead, ...infer RightRest] ? [[Left[number], RightHead], ...Zip<Left, RightRest>] : Array<[Left[number], Right[number]]>;
-export declare namespace zip {
-    const strict: Strict;
-}
-export {};
-//# sourceMappingURL=zip.d.ts.map

package/dist/types/array/zip.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zip.d.ts","sourceRoot":"","sources":["../../../src/array/zip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EACtB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GACvB,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAEjB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,GAAG,CAAC,CAAC,EACnB,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GACvB,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAoBjD,UAAU,MAAM;IACd,CAAC,CAAC,SAAS,iBAAiB,EAAE,CAAC,SAAS,iBAAiB,EACvD,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,CAAC,GACR,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAEb,CAAC,CAAC,SAAS,iBAAiB,EAC1B,MAAM,EAAE,CAAC,GACR,CAAC,CAAC,SAAS,iBAAiB,EAAE,KAAK,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACzD;AAED,KAAK,GAAG,CAAC,IAAI,SAAS,iBAAiB,EAAE,KAAK,SAAS,iBAAiB,IAEtE,IAAI,SAAS,SAAS,EAAE,GACpB,EAAE,GACF,KAAK,SAAS,SAAS,EAAE,GACvB,EAAE,GAEJ,IAAI,SAAS,SAAS,CAAC,MAAM,QAAQ,EAAE,GAAG,MAAM,QAAQ,CAAC,GACrD,KAAK,SAAS,SAAS,CAAC,MAAM,SAAS,EAAE,GAAG,MAAM,SAAS,CAAC,GAE1D;IAAC,CAAC,QAAQ,EAAE,SAAS,CAAC;IAAE,GAAG,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC;CAAC,GAGpD;IAAC,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAAE,GAAG,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;CAAC,GACtD,KAAK,SAAS,SAAS,CAAC,MAAM,SAAS,EAAE,GAAG,MAAM,SAAS,CAAC,GAC1D,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,GAGtD,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAE/C,yBAAiB,GAAG,CAAC;IAGZ,MAAM,MAAM,EAAE,MAAY,CAAC;CACnC"}

package/dist/types/function/conditional.d.ts

@@ -1,107 +0,0 @@
-type Case<In, Out, Thru extends In = In> = readonly [
-    when: ((data: In) => boolean) | ((data: In) => data is Thru),
-    then: (data: Thru) => Out
-];
-/**
- * Executes a transformer function based on the first matching predicate,
- * functioning like a series of `if...else if...` statements. It sequentially
- * evaluates each case and, upon finding a truthy predicate, runs the
- * corresponding transformer, and returns, ignoring any further cases, even if
- * they would match.
- *
- * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
- * Ramda, this implementation does **NOT** return a default/fallback
- * `undefined` value when none of the cases match; and instead will **throw** an
- * exception in those cases.
- * To add a default case use the `conditional.defaultCase` helper as the final
- * case of your implementation. By default it returns `undefined`, but could be
- * provided a transformer in order to return something else.
- *
- * Due to TypeScript's inability to infer the result of negating a type-
- * predicate we can't refine the types used in subsequent cases based on
- * previous conditions. Using a `switch (true)` statement or ternary operators
- * is recommended for more precise type control when such type narrowing is
- * needed.
- *
- * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
- * consists of a predicate (or a type-predicate) and a transformer function that
- * processes the data if its case matches.
- * @returns The output of the matched transformer. If no cases match, an
- * exception is thrown. The return type is a union of the return types of all
- * provided transformers.
- * @signature
- *   P.conditional(...cases)(data);
- * @example
- *   const nameOrId = 3 as string | number;
- *   P.pipe(
- *     nameOrId,
- *     P.conditional(
- *       [P.isString, (name) => `Hello ${name}`],
- *       [P.isNumber, (id) => `Hello ID: ${id}`],
- *       P.conditional.defaultCase(
- *         (something) => `Hello something (${JSON.stringify(something)})`,
- *       ),
- *     ),
- *   ); //=> 'Hello ID: 3'
- * @dataLast
- * @category Function
- */
-export declare function conditional<T, Return0, Return1 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = never, Thru0 extends T = T, Thru1 extends T = T, Thru2 extends T = T, Thru3 extends T = T, Thru4 extends T = T, Thru5 extends T = T, Thru6 extends T = T, Thru7 extends T = T, Thru8 extends T = T, Thru9 extends T = T>(case0: Case<T, Return0, Thru0>, case1?: Case<T, Return1, Thru1>, case2?: Case<T, Return2, Thru2>, case3?: Case<T, Return3, Thru3>, case4?: Case<T, Return4, Thru4>, case5?: Case<T, Return5, Thru5>, case6?: Case<T, Return6, Thru6>, case7?: Case<T, Return7, Thru7>, case8?: Case<T, Return8, Thru8>, case9?: Case<T, Return9, Thru9>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
-/**
- * Executes a transformer function based on the first matching predicate,
- * functioning like a series of `if...else if...` statements. It sequentially
- * evaluates each case and, upon finding a truthy predicate, runs the
- * corresponding transformer, and returns, ignoring any further cases, even if
- * they would match.
- *
- * !IMPORTANT! - Unlike similar implementations in frameworks like Lodash and
- * Ramda, this implementation does **NOT** return a default/fallback
- * `undefined` value when none of the cases match; and instead will **throw** an
- * exception in those cases.
- * To add a default case use the `conditional.defaultCase` helper as the final
- * case of your implementation. By default it returns `undefined`, but could be
- * provided a transformer in order to return something else.
- *
- * Due to TypeScript's inability to infer the result of negating a type-
- * predicate we can't refine the types used in subsequent cases based on
- * previous conditions. Using a `switch (true)` statement or ternary operators
- * is recommended for more precise type control when such type narrowing is
- * needed.
- *
- * @param data - The input data to be evaluated against the provided cases.
- * @param cases - A list of (up to 10) tuples, each defining a case. Each tuple
- * consists of a predicate (or a type-predicate) and a transformer function that
- * processes the data if its case matches.
- * @returns The output of the matched transformer. If no cases match, an
- * exception is thrown. The return type is a union of the return types of all
- * provided transformers.
- * @signature
- *   P.conditional(data, ...cases);
- * @example
- *   const nameOrId = 3 as string | number;
- *   P.conditional(
- *     nameOrId,
- *     [P.isString, (name) => `Hello ${name}`],
- *     [P.isNumber, (id) => `Hello ID: ${id}`],
- *     P.conditional.defaultCase(
- *       (something) => `Hello something (${JSON.stringify(something)})`,
- *     ),
- *   ); //=> 'Hello ID: 3'
- * @dataFirst
- * @category Function
- */
-export declare function conditional<T, Return0, Return1 = never, Return2 = never, Return3 = never, Return4 = never, Return5 = never, Return6 = never, Return7 = never, Return8 = never, Return9 = never, Thru0 extends T = T, Thru1 extends T = T, Thru2 extends T = T, Thru3 extends T = T, Thru4 extends T = T, Thru5 extends T = T, Thru6 extends T = T, Thru7 extends T = T, Thru8 extends T = T, Thru9 extends T = T>(data: T, case0: Case<T, Return0, Thru0>, case1?: Case<T, Return1, Thru1>, case2?: Case<T, Return2, Thru2>, case3?: Case<T, Return3, Thru3>, case4?: Case<T, Return4, Thru4>, case5?: Case<T, Return5, Thru5>, case6?: Case<T, Return6, Thru6>, case7?: Case<T, Return7, Thru7>, case8?: Case<T, Return8, Thru8>, case9?: Case<T, Return9, Thru9>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9;
-export declare namespace conditional {
-    /**
-     * A simplified case that accepts all data. Put this as the last case to
-     * prevent an exception from being thrown when none of the previous cases
-     * match.
-     * If this is not the last case it will short-circuit anything after it.
-     * @param then - You only need to provide the transformer, the predicate is
-     * implicit. @default () => undefined, which is how Lodash and Ramda handle
-     * the final fallback case.
-     */
-    function defaultCase<In>(then?: (data: In) => unknown): readonly [() => boolean, (data: In) => unknown];
-}
-export {};
-//# sourceMappingURL=conditional.d.ts.map

package/dist/types/function/conditional.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"conditional.d.ts","sourceRoot":"","sources":["../../../src/function/conditional.ts"],"names":[],"mappings":"AAEA,KAAK,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,IAAI,SAAS,EAAE,GAAG,EAAE,IAAI,SAAS;IAClD,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,KAAK,IAAI,IAAI,IAAI,CAAC;IAC5D,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,GAAG;CAC1B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,WAAW,CACzB,CAAC,EACD,OAAO,EACP,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EAEnB,KAAK,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,GAC9B,CACD,IAAI,EAAE,CAAC,KAEP,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,CAAC;AAEV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,WAAW,CACzB,CAAC,EACD,OAAO,EACP,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,OAAO,GAAG,KAAK,EACf,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EACnB,KAAK,SAAS,CAAC,GAAG,CAAC,EAEnB,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAC/B,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,GAE7B,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,GACP,OAAO,CAAC;AAsCZ,yBAAiB,WAAW,CAAC;IAC3B;;;;;;;;OAQG;IACH,SAAgB,WAAW,CAAC,EAAE,EAAE,IAAI,GAAE,CAAC,IAAI,EAAE,EAAE,KAAK,OAA4B,mCAAnC,EAAE,KAAK,OAAO,EAE1D;CACF"}

package/dist/types/function/create-pipe.d.ts

@@ -1,19 +0,0 @@
-/**
- * Creates a data-last pipe function. First function must be always annotated. Other functions are automatically inferred.
- * @signature
- *    P.createPipe(op1, op2, op3)(data);
- * @example
- *    P.createPipe(
- *      (x: number) => x * 2,
- *      x => x * 3
- *    )(1) // => 6
- * @category Function
- */
-export declare function createPipe<A, B>(op1: (input: A) => B): (value: A) => B;
-export declare function createPipe<A, B, C>(op1: (input: A) => B, op2: (input: B) => C): (value: A) => C;
-export declare function createPipe<A, B, C, D>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D): (value: A) => D;
-export declare function createPipe<A, B, C, D, E>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E): (value: A) => E;
-export declare function createPipe<A, B, C, D, E, F>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F): (value: A) => F;
-export declare function createPipe<A, B, C, D, E, F, G>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G): (value: A) => G;
-export declare function createPipe<A, B, C, D, E, F, G, H>(op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H): (value: A) => H;
-//# sourceMappingURL=create-pipe.d.ts.map

package/dist/types/function/create-pipe.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-pipe.d.ts","sourceRoot":"","sources":["../../../src/function/create-pipe.ts"],"names":[],"mappings":"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"}

package/dist/types/function/debounce.d.ts

@@ -1,92 +0,0 @@
-interface Debouncer<F extends (...args: any) => unknown, IsNullable extends boolean = true> {
-    /**
-     * The last computed value of the debounced function.
-     */
-    readonly cachedValue: ReturnType<F> | undefined;
-    /**
-     * Invoke the debounced function.
-     * @param args - same as the args for the debounced function.
-     * @returns - the last computed value of the debounced function with the
-     * latest args provided to it. If `timing` does not include `leading` then the
-     * the function would return `undefined` until the first cool-down period is
-     * over, otherwise the function would always return the return type of the
-     * debounced function.
-     */
-    readonly call: (...args: Parameters<F>) => ReturnType<F> | (true extends IsNullable ? undefined : never);
-    /**
-     * Cancels any debounced functions without calling them, effectively resetting
-     * the debouncer to the same state it is when initially created.
-     */
-    readonly cancel: () => void;
-    /**
-     * Similar to `cancel`, but would also trigger the `trailing` invocation if
-     * the debouncer would run one at the end of the cool-down period.
-     */
-    readonly flush: () => ReturnType<F> | undefined;
-    /**
-     * Is `true` when there is an active cool-down period currently debouncing
-     * invocations.
-     */
-    readonly isPending: boolean;
-}
-interface DebounceOptions {
-    readonly maxWaitMs?: number;
-    readonly waitMs?: number;
-}
-/**
- * Wraps `func` with a debouncer object that "debounces" (delays) invocations of the function during a defined cool-down period (`waitMs`). It can be configured to invoke the function either at the start of the cool-down period, the end of it, or at both ends (`timing`).
- * It can also be configured to allow invocations during the cool-down period (`maxWaitMs`).
- * It stores the latest call's arguments so they could be used at the end of the cool-down period when invoking `func` (if configured to invoke the function at the end of the cool-down period).
- * It stores the value returned by `func` whenever its invoked. This value is returned on every call, and is accessible via the `cachedValue` property of the debouncer. Its important to note that the value might be different from the value that would be returned from running `func` with the current arguments as it is a cached value from a previous invocation.
- * **Important**: The cool-down period defines the minimum between two invocations, and not the maximum. The period will be **extended** each time a call is made until a full cool-down period has elapsed without any additional calls.
- * @param func The function to debounce, the returned `call` function will have
- * the exact same signature.
- * @param options An object allowing further customization of the debouncer:
- * - `timing?: 'leading' | 'trailing' |'both'`. The default is `'trailing'`.
- *   `leading` would result in the function being invoked at the start of the
- *   cool-down period; `trailing` would result in the function being invoked at
- *   the end of the cool-down period (using the args from the last call to the
- *   debouncer). When `both` is selected the `trailing` invocation would only
- *   take place if there were more than one call to the debouncer during the
- *   cool-down period. **DEFAULT: 'trailing'**
- * - `waitMs?: number`. The length of the cool-down period in milliseconds. The
- *   debouncer would wait until this amount of time has passed without **any**
- *   additional calls to the debouncer before triggering the end-of-cool-down-
- *   period event. When this happens, the function would be invoked (if `timing`
- *   isn't `'leading'`) and the debouncer state would be reset. **DEFAULT: 0**
- * - `maxWaitMs?: number`. The length of time since a debounced call (a call
- *   that the debouncer prevented from being invoked) was made until it would be
- *   invoked. Because the debouncer can be continually triggered and thus never
- *   reach the end of the cool-down period, this allows the function to still
- *   be invoked occasionally. IMPORTANT: This param is ignored when `timing` is
- *   `'leading'`.
- * @returns a debouncer object. The main function is `call`. In addition to it
- * the debouncer comes with the following additional functions and properties:
- * - `cancel` method to cancel delayed `func` invocations
- * - `flush` method to end the cool-down period immediately.
- * - `cachedValue` the latest return value of an invocation (if one occurred).
- * - `isPending` flag to check if there is an inflight cool-down window.
- * @signature
- *   P.debounce(func, options);
- * @example
- *   const debouncer = debounce(identity, { timing: 'trailing', waitMs: 1000 });
- *   const result1 = debouncer.call(1); // => undefined
- *   const result2 = debouncer.call(2); // => undefined
- *   // after 1 second
- *   const result3 = debouncer.call(3); // => 2
- *   // after 1 second
- *   debouncer.cachedValue; // => 3
- * @dataFirst
- * @category Function
- * @see https://css-tricks.com/debouncing-throttling-explained-examples/
- */
-export declare function debounce<F extends (...args: any) => any>(func: F, options: {
-    readonly timing?: 'trailing';
-} & DebounceOptions): Debouncer<F>;
-export declare function debounce<F extends (...args: any) => any>(func: F, options: ({
-    readonly timing: 'both';
-} & DebounceOptions) | ({
-    readonly timing: 'leading';
-} & Omit<DebounceOptions, 'maxWaitMs'>)): Debouncer<F, false>;
-export {};
-//# sourceMappingURL=debounce.d.ts.map

package/dist/types/function/debounce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../src/function/debounce.ts"],"names":[],"mappings":"AAAA,UAAU,SAAS,CACjB,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,OAAO,EACnC,UAAU,SAAS,OAAO,GAAG,IAAI;IAEjC;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAEhD;;;;;;;;OAQG;IACH,QAAQ,CAAC,IAAI,EAAE,CACb,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KACnB,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,SAAS,UAAU,GAAG,SAAS,GAAG,KAAK,CAAC,CAAC;IAEnE;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;IAE5B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAEhD;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,UAAU,eAAe;IACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,EACtD,IAAI,EAAE,CAAC,EACP,OAAO,EAAE;IAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,CAAA;CAAE,GAAG,eAAe,GAC1D,SAAS,CAAC,CAAC,CAAC,CAAC;AAEhB,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,EACtD,IAAI,EAAE,CAAC,EACP,OAAO,EACL,CAAC;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,eAAe,CAAC,GAC/C,CAAC;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;CAAE,GAAG,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC,GACtE,SAAS,CAAC,CAAC,EAAE,KAAK,CAA8B,CAAC"}

package/dist/types/function/identity.d.ts

@@ -1,10 +0,0 @@
-/**
- * A function that always returns the param passed to it
- * @signature
- *    P.identity(data)
- * @example
- *    P.identity('foo') // => 'foo'
- * @category Function
- */
-export declare function identity<T>(value: T): T;
-//# sourceMappingURL=identity.d.ts.map

package/dist/types/function/identity.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../../src/function/identity.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAEnC"}

package/dist/types/function/index.d.ts

@@ -1,11 +0,0 @@
-export * from './conditional';
-export * from './create-pipe';
-export * from './identity';
-export * from './noop';
-export * from './once';
-export * from './debounce';
-export * from './pipe';
-export * from './purry';
-export * from './sleep';
-export * from './times';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/function/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/function/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}

package/dist/types/function/noop.d.ts

@@ -1,10 +0,0 @@
-/**
- * A function that returns always `undefined`.
- * @signature
- *    P.noop()
- * @example
- *    onSomething(P.noop)
- * @category Function
- */
-export declare function noop(): undefined;
-//# sourceMappingURL=noop.d.ts.map

package/dist/types/function/noop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"noop.d.ts","sourceRoot":"","sources":["../../../src/function/noop.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,IAAI,IAAI,SAAS,CAEhC"}

package/dist/types/function/once.d.ts

@@ -1,13 +0,0 @@
-/**
- * Creates a function that is restricted to invoking `func` once. Repeat calls to the function return the value of the first invocation.
- * @param fn the function to wrap
- * @signature P.once(fn)
- * @example
- * const initialize = P.once(createApplication);
- * initialize();
- * initialize();
- * // => `createApplication` is invoked once
- * @category Function
- */
-export declare function once<T>(fn: () => T): () => T;
-//# sourceMappingURL=once.d.ts.map

package/dist/types/function/once.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"once.d.ts","sourceRoot":"","sources":["../../../src/function/once.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,CAU5C"}

package/dist/types/function/pipe.d.ts

@@ -1,53 +0,0 @@
-export type LazyEvaluator<T = unknown, R = T> = (item: T, index?: number, data?: ReadonlyArray<T>) => LazyResult<R>;
-type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
-interface LazyEmpty {
-    done: boolean;
-    hasMany?: false | undefined;
-    hasNext: false;
-    next?: undefined;
-}
-interface LazyNext<T> {
-    done: boolean;
-    hasMany?: false | undefined;
-    hasNext: true;
-    next: T;
-}
-interface LazyMany<T> {
-    done: boolean;
-    hasMany: true;
-    hasNext: true;
-    next: Array<T>;
-}
-/**
- * Perform left-to-right function composition.
- * @param value The initial value.
- * @param arguments the list of operations to apply.
- * @signature P.pipe(data, op1, op2, op3)
- * @example
- *    P.pipe(
- *      [1, 2, 3, 4],
- *      P.map(x => x * 2),
- *      arr => [arr[0] + arr[1], arr[2] + arr[3]],
- *    ) // => [6, 14]
- *
- *
- * @dataFirst
- * @category Function
- */
-export declare function pipe<A, B>(value: A, op1: (input: A) => B): B;
-export declare function pipe<A, B, C>(value: A, op1: (input: A) => B, op2: (input: B) => C): C;
-export declare function pipe<A, B, C, D>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D): D;
-export declare function pipe<A, B, C, D, E>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E): E;
-export declare function pipe<A, B, C, D, E, F>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F): F;
-export declare function pipe<A, B, C, D, E, F, G>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G): G;
-export declare function pipe<A, B, C, D, E, F, G, H>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H): H;
-export declare function pipe<A, B, C, D, E, F, G, H, I>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H, op8: (input: H) => I): I;
-export declare function pipe<A, B, C, D, E, F, G, H, I, J>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H, op8: (input: H) => I, op9: (input: I) => J): J;
-export declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K): K;
-export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L): L;
-export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M): M;
-export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M, op13: (input: M) => N): N;
-export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M, op13: (input: M) => N, op14: (input: N) => O): O;
-export declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M, op13: (input: M) => N, op14: (input: N) => O, op15: (input: O) => P): P;
-export {};
-//# sourceMappingURL=pipe.d.ts.map