diff --git a/ramda/dist/src/all.d.ts b/ramda/dist/src/all.d.ts index e7982c6..fc4719f 100644 --- a/ramda/dist/src/all.d.ts +++ b/ramda/dist/src/all.d.ts @@ -27,17 +27,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const all: all_00; type all_00 = { (_fn: PH, list: List): all_01; - (fn: Predicate, list: List): all_11; - <$SEL extends "11">(): (fn: Predicate, list: List) => all_11; + (fn: Predicate, list: List): all_11; + <$SEL extends "11">(): (fn: Predicate, list: List) => all_11; <$SEL extends "1">(): (fn: Predicate) => all_10; <$SEL extends "01">(): (_fn: PH, list: List) => all_01; (fn: Predicate): all_10; }; type all_10 = { - (list: List): all_11; + (list: List): all_11; }; type all_01 = { - (fn: Predicate): all_11; + (fn: Predicate): all_11; }; -type all_11 = boolean; +type all_11 = boolean; export = all; diff --git a/ramda/dist/src/any.d.ts b/ramda/dist/src/any.d.ts index bf3ddce..c6eefb3 100644 --- a/ramda/dist/src/any.d.ts +++ b/ramda/dist/src/any.d.ts @@ -28,17 +28,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const any: any_00; type any_00 = { (_fn: PH, list: List): any_01; - (fn: Predicate, list: List): any_11; - <$SEL extends "11">(): (fn: Predicate, list: List) => any_11; + (fn: Predicate, list: List): any_11; + <$SEL extends "11">(): (fn: Predicate, list: List) => any_11; <$SEL extends "1">(): (fn: Predicate) => any_10; <$SEL extends "01">(): (_fn: PH, list: List) => any_01; (fn: Predicate): any_10; }; type any_10 = { - (list: List): any_11; + (list: List): any_11; }; type any_01 = { - (fn: Predicate): any_11; + (fn: Predicate): any_11; }; -type any_11 = boolean; +type any_11 = boolean; export = any; diff --git a/ramda/dist/src/ap.d.ts b/ramda/dist/src/ap.d.ts index efdd966..7e5bba6 100644 --- a/ramda/dist/src/ap.d.ts +++ b/ramda/dist/src/ap.d.ts @@ -24,17 +24,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const ap: ap_00; type ap_00 = { (_fns: PH, list: List): ap_01; - (fns: Morphism[], list: List): ap_11; - <$SEL extends "11">(): (fns: Morphism[], list: List) => ap_11; + (fns: Morphism[], list: List): ap_11; + <$SEL extends "11">(): (fns: Morphism[], list: List) => ap_11; <$SEL extends "1">(): (fns: Morphism[]) => ap_10; <$SEL extends "01">(): (_fns: PH, list: List) => ap_01; (fns: Morphism[]): ap_10; }; type ap_10 = { - (list: List): ap_11; + (list: List): ap_11; }; type ap_01 = { - (fns: Morphism[]): ap_11; + (fns: Morphism[]): ap_11; }; -type ap_11 = U[]; +type ap_11 = U[]; export = ap; diff --git a/ramda/dist/src/ascend.d.ts b/ramda/dist/src/ascend.d.ts index c38d87b..f1f5d6f 100644 --- a/ramda/dist/src/ascend.d.ts +++ b/ramda/dist/src/ascend.d.ts @@ -27,10 +27,10 @@ type ascend_000 = { (fn: Morphism, _a: PH, b: T): ascend_101; (_fn: PH, a: T, b: T): ascend_011; (_fn: PH, _a: PH, b: T): ascend_001; - (fn: Morphism, a: T, b: T): ascend_111; + (fn: Morphism, a: T, b: T): ascend_111; (_fn: PH, a: T): ascend_010; (fn: Morphism, a: T): ascend_110; - <$SEL extends "111">(): (fn: Morphism, a: T, b: T) => ascend_111; + <$SEL extends "111">(): (fn: Morphism, a: T, b: T) => ascend_111; <$SEL extends "11">(): (fn: Morphism, a: T) => ascend_110; <$SEL extends "101">(): (fn: Morphism, _a: PH, b: T) => ascend_101; <$SEL extends "1">(): (fn: Morphism) => ascend_100; @@ -41,36 +41,36 @@ type ascend_000 = { }; type ascend_100 = { (_a: PH, b: T): ascend_101; - (a: T, b: T): ascend_111; - <$SEL extends "11">(): (a: T, b: T) => ascend_111; + (a: T, b: T): ascend_111; + <$SEL extends "11">(): (a: T, b: T) => ascend_111; <$SEL extends "1">(): (a: T) => ascend_110; <$SEL extends "01">(): (_a: PH, b: T) => ascend_101; (a: T): ascend_110; }; type ascend_010 = { (_fn: PH, b: T): ascend_011; - (fn: Morphism, b: T): ascend_111; - <$SEL extends "11">(): (fn: Morphism, b: T) => ascend_111; + (fn: Morphism, b: T): ascend_111; + <$SEL extends "11">(): (fn: Morphism, b: T) => ascend_111; <$SEL extends "1">(): (fn: Morphism) => ascend_110; <$SEL extends "01">(): (_fn: PH, b: T) => ascend_011; (fn: Morphism): ascend_110; }; type ascend_110 = { - (b: T): ascend_111; + (b: T): ascend_111; }; type ascend_001 = { (_fn: PH, a: T): ascend_011; - (fn: Morphism, a: T): ascend_111; - <$SEL extends "11">(): (fn: Morphism, a: T) => ascend_111; + (fn: Morphism, a: T): ascend_111; + <$SEL extends "11">(): (fn: Morphism, a: T) => ascend_111; <$SEL extends "1">(): (fn: Morphism) => ascend_101; <$SEL extends "01">(): (_fn: PH, a: T) => ascend_011; (fn: Morphism): ascend_101; }; type ascend_101 = { - (a: T): ascend_111; + (a: T): ascend_111; }; type ascend_011 = { - (fn: Morphism): ascend_111; + (fn: Morphism): ascend_111; }; -type ascend_111 = number; +type ascend_111 = number; export = ascend; diff --git a/ramda/dist/src/chain.d.ts b/ramda/dist/src/chain.d.ts index af39f60..60dbd9a 100644 --- a/ramda/dist/src/chain.d.ts +++ b/ramda/dist/src/chain.d.ts @@ -28,53 +28,53 @@ type chain_00 = { (_fn: PH, list: Chain): chain_chain_01; (_fn: PH, monad: Morphism, V>): chain_listFn_01; (_fn: PH, monad: Morphism, V>): chain_chainFn_01; - (fn: Morphism>, list: List): chain_list_11; - (fn: Morphism>, list: Chain): chain_chain_11; - (fn: NestedMorphism, U>, monad: Morphism, V>): chain_listFn_11; - (fn: NestedMorphism, Chain>, monad: Morphism, V>): chain_chainFn_11; + (fn: Morphism>, list: List): chain_list_11; + (fn: Morphism>, list: Chain): chain_chain_11; + (fn: NestedMorphism, U>, monad: Morphism, V>): chain_listFn_11; + (fn: NestedMorphism, Chain>, monad: Morphism, V>): chain_chainFn_11; (fn: Morphism>): chain_list_10; (fn: Morphism>): chain_chain_10; (fn: NestedMorphism, U>): chain_listFn_10; - <$SEL extends "11", $KIND extends "list">(): (fn: Morphism>, list: List) => chain_list_11; + <$SEL extends "11", $KIND extends "list">(): (fn: Morphism>, list: List) => chain_list_11; <$SEL extends "1", $KIND extends "list">(): (fn: Morphism>) => chain_list_10; <$SEL extends "01", $KIND extends "list">(): (_fn: PH, list: List) => chain_list_01; - <$SEL extends "11", $KIND extends "chain">(): (fn: Morphism>, list: Chain) => chain_chain_11; + <$SEL extends "11", $KIND extends "chain">(): (fn: Morphism>, list: Chain) => chain_chain_11; <$SEL extends "1", $KIND extends "chain">(): (fn: Morphism>) => chain_chain_10; <$SEL extends "01", $KIND extends "chain">(): (_fn: PH, list: Chain) => chain_chain_01; - <$SEL extends "11", $KIND extends "listFn">(): (fn: NestedMorphism, U>, monad: Morphism, V>) => chain_listFn_11; + <$SEL extends "11", $KIND extends "listFn">(): (fn: NestedMorphism, U>, monad: Morphism, V>) => chain_listFn_11; <$SEL extends "1", $KIND extends "listFn">(): (fn: NestedMorphism, U>) => chain_listFn_10; <$SEL extends "01", $KIND extends "listFn">(): (_fn: PH, monad: Morphism, V>) => chain_listFn_01; - <$SEL extends "11", $KIND extends "chainFn">(): (fn: NestedMorphism, Chain>, monad: Morphism, V>) => chain_chainFn_11; + <$SEL extends "11", $KIND extends "chainFn">(): (fn: NestedMorphism, Chain>, monad: Morphism, V>) => chain_chainFn_11; <$SEL extends "1", $KIND extends "chainFn">(): (fn: NestedMorphism, Chain>) => chain_chainFn_10; <$SEL extends "01", $KIND extends "chainFn">(): (_fn: PH, monad: Morphism, V>) => chain_chainFn_01; (fn: NestedMorphism, Chain>): chain_chainFn_10; }; type chain_list_10 = { - (list: List): chain_list_11; + (list: List): chain_list_11; }; type chain_chain_10 = { - (list: Chain): chain_chain_11; + (list: Chain): chain_chain_11; }; type chain_listFn_10 = { - (monad: Morphism, V>): chain_listFn_11; + (monad: Morphism, V>): chain_listFn_11; }; type chain_chainFn_10 = { - (monad: Morphism, V>): chain_chainFn_11; + (monad: Morphism, V>): chain_chainFn_11; }; type chain_list_01 = { - (fn: Morphism>): chain_list_11; + (fn: Morphism>): chain_list_11; }; type chain_chain_01 = { - (fn: Morphism>): chain_chain_11; + (fn: Morphism>): chain_chain_11; }; type chain_listFn_01 = { - (fn: NestedMorphism, U>): chain_listFn_11; + (fn: NestedMorphism, U>): chain_listFn_11; }; type chain_chainFn_01 = { - (fn: NestedMorphism, Chain>): chain_chainFn_11; + (fn: NestedMorphism, Chain>): chain_chainFn_11; }; -type chain_list_11 = U[]; -type chain_chain_11 = Chain; -type chain_listFn_11 = Morphism, U>; -type chain_chainFn_11 = Morphism, Chain>; +type chain_list_11 = U[]; +type chain_chain_11 = Chain; +type chain_listFn_11 = Morphism, U>; +type chain_chainFn_11 = Morphism, Chain>; export = chain; diff --git a/ramda/dist/src/contains.d.ts b/ramda/dist/src/contains.d.ts index be9c8fb..e3dcb62 100644 --- a/ramda/dist/src/contains.d.ts +++ b/ramda/dist/src/contains.d.ts @@ -23,17 +23,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const contains: contains_00; type contains_00 = { (_value: PH, list: List): contains_01; - (value: T, list: List): contains_11; - <$SEL extends "11">(): (value: T, list: List) => contains_11; + (value: T, list: List): contains_11; + <$SEL extends "11">(): (value: T, list: List) => contains_11; <$SEL extends "1">(): (value: T) => contains_10; <$SEL extends "01">(): (_value: PH, list: List) => contains_01; (value: T): contains_10; }; type contains_10 = { - (list: List): contains_11; + (list: List): contains_11; }; type contains_01 = { - (value: T): contains_11; + (value: T): contains_11; }; -type contains_11 = boolean; +type contains_11 = boolean; export = contains; diff --git a/ramda/dist/src/converge.d.ts b/ramda/dist/src/converge.d.ts index c068062..2b089ae 100644 --- a/ramda/dist/src/converge.d.ts +++ b/ramda/dist/src/converge.d.ts @@ -49,24 +49,24 @@ type converge_00 = { (_after: PH, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5]): converge_i3f5_01; (_after: PH, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5, (v1: T1, v2: T2, v3: T3) => U6]): converge_i3f6_01; (_after: PH, fns: List>): converge_variadic_01; - (after: (v1: U1) => R, fns: [(v1: T1) => U1]): converge_i1f1_11; - (after: (v1: U1, v2: U2) => R, fns: [(v1: T1) => U1, (v1: T1) => U2]): converge_i1f2_11; - (after: (v1: U1, v2: U2, v3: U3) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3]): converge_i1f3_11; - (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4]): converge_i1f4_11; - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5]): converge_i1f5_11; - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5, (v1: T1) => U6]): converge_i1f6_11; - (after: (v1: U1) => R, fns: [(v1: T1, v2: T2) => U1]): converge_i2f1_11; - (after: (v1: U1, v2: U2) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2]): converge_i2f2_11; - (after: (v1: U1, v2: U2, v3: U3) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3]): converge_i2f3_11; - (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4]): converge_i2f4_11; - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5]): converge_i2f5_11; - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5, (v1: T1, v2: T2) => U6]): converge_i2f6_11; - (after: (v1: U1) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1]): converge_i3f1_11; - (after: (v1: U1, v2: U2) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2]): converge_i3f2_11; - (after: (v1: U1, v2: U2, v3: U3) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3]): converge_i3f3_11; - (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4]): converge_i3f4_11; - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5]): converge_i3f5_11; - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5, (v1: T1, v2: T2, v3: T3) => U6]): converge_i3f6_11; + (after: (v1: U1) => R, fns: [(v1: T1) => U1]): converge_i1f1_11; + (after: (v1: U1, v2: U2) => R, fns: [(v1: T1) => U1, (v1: T1) => U2]): converge_i1f2_11; + (after: (v1: U1, v2: U2, v3: U3) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3]): converge_i1f3_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4]): converge_i1f4_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5]): converge_i1f5_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5, (v1: T1) => U6]): converge_i1f6_11; + (after: (v1: U1) => R, fns: [(v1: T1, v2: T2) => U1]): converge_i2f1_11; + (after: (v1: U1, v2: U2) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2]): converge_i2f2_11; + (after: (v1: U1, v2: U2, v3: U3) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3]): converge_i2f3_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4]): converge_i2f4_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5]): converge_i2f5_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5, (v1: T1, v2: T2) => U6]): converge_i2f6_11; + (after: (v1: U1) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1]): converge_i3f1_11; + (after: (v1: U1, v2: U2) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2]): converge_i3f2_11; + (after: (v1: U1, v2: U2, v3: U3) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3]): converge_i3f3_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4]): converge_i3f4_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5]): converge_i3f5_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5, (v1: T1, v2: T2, v3: T3) => U6]): converge_i3f6_11; (after: Variadic, fns: List>): converge_variadic_11; (after: (v1: U1) => R): converge_i1f1_10; (after: (v1: U1, v2: U2) => R): converge_i1f2_10; @@ -86,58 +86,58 @@ type converge_00 = { (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R): converge_i3f4_10; (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R): converge_i3f5_10; (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R): converge_i3f6_10; - <$SEL extends "11", $KIND extends "i1f1">(): (after: (v1: U1) => R, fns: [(v1: T1) => U1]) => converge_i1f1_11; + <$SEL extends "11", $KIND extends "i1f1">(): (after: (v1: U1) => R, fns: [(v1: T1) => U1]) => converge_i1f1_11; <$SEL extends "1", $KIND extends "i1f1">(): (after: (v1: U1) => R) => converge_i1f1_10; <$SEL extends "01", $KIND extends "i1f1">(): (_after: PH, fns: [(v1: T1) => U1]) => converge_i1f1_01; - <$SEL extends "11", $KIND extends "i1f2">(): (after: (v1: U1, v2: U2) => R, fns: [(v1: T1) => U1, (v1: T1) => U2]) => converge_i1f2_11; + <$SEL extends "11", $KIND extends "i1f2">(): (after: (v1: U1, v2: U2) => R, fns: [(v1: T1) => U1, (v1: T1) => U2]) => converge_i1f2_11; <$SEL extends "1", $KIND extends "i1f2">(): (after: (v1: U1, v2: U2) => R) => converge_i1f2_10; <$SEL extends "01", $KIND extends "i1f2">(): (_after: PH, fns: [(v1: T1) => U1, (v1: T1) => U2]) => converge_i1f2_01; - <$SEL extends "11", $KIND extends "i1f3">(): (after: (v1: U1, v2: U2, v3: U3) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3]) => converge_i1f3_11; + <$SEL extends "11", $KIND extends "i1f3">(): (after: (v1: U1, v2: U2, v3: U3) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3]) => converge_i1f3_11; <$SEL extends "1", $KIND extends "i1f3">(): (after: (v1: U1, v2: U2, v3: U3) => R) => converge_i1f3_10; <$SEL extends "01", $KIND extends "i1f3">(): (_after: PH, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3]) => converge_i1f3_01; - <$SEL extends "11", $KIND extends "i1f4">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4]) => converge_i1f4_11; + <$SEL extends "11", $KIND extends "i1f4">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4]) => converge_i1f4_11; <$SEL extends "1", $KIND extends "i1f4">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R) => converge_i1f4_10; <$SEL extends "01", $KIND extends "i1f4">(): (_after: PH, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4]) => converge_i1f4_01; - <$SEL extends "11", $KIND extends "i1f5">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5]) => converge_i1f5_11; + <$SEL extends "11", $KIND extends "i1f5">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5]) => converge_i1f5_11; <$SEL extends "1", $KIND extends "i1f5">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R) => converge_i1f5_10; <$SEL extends "01", $KIND extends "i1f5">(): (_after: PH, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5]) => converge_i1f5_01; - <$SEL extends "11", $KIND extends "i1f6">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5, (v1: T1) => U6]) => converge_i1f6_11; + <$SEL extends "11", $KIND extends "i1f6">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5, (v1: T1) => U6]) => converge_i1f6_11; <$SEL extends "1", $KIND extends "i1f6">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R) => converge_i1f6_10; <$SEL extends "01", $KIND extends "i1f6">(): (_after: PH, fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5, (v1: T1) => U6]) => converge_i1f6_01; - <$SEL extends "11", $KIND extends "i2f1">(): (after: (v1: U1) => R, fns: [(v1: T1, v2: T2) => U1]) => converge_i2f1_11; + <$SEL extends "11", $KIND extends "i2f1">(): (after: (v1: U1) => R, fns: [(v1: T1, v2: T2) => U1]) => converge_i2f1_11; <$SEL extends "1", $KIND extends "i2f1">(): (after: (v1: U1) => R) => converge_i2f1_10; <$SEL extends "01", $KIND extends "i2f1">(): (_after: PH, fns: [(v1: T1, v2: T2) => U1]) => converge_i2f1_01; - <$SEL extends "11", $KIND extends "i2f2">(): (after: (v1: U1, v2: U2) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2]) => converge_i2f2_11; + <$SEL extends "11", $KIND extends "i2f2">(): (after: (v1: U1, v2: U2) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2]) => converge_i2f2_11; <$SEL extends "1", $KIND extends "i2f2">(): (after: (v1: U1, v2: U2) => R) => converge_i2f2_10; <$SEL extends "01", $KIND extends "i2f2">(): (_after: PH, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2]) => converge_i2f2_01; - <$SEL extends "11", $KIND extends "i2f3">(): (after: (v1: U1, v2: U2, v3: U3) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3]) => converge_i2f3_11; + <$SEL extends "11", $KIND extends "i2f3">(): (after: (v1: U1, v2: U2, v3: U3) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3]) => converge_i2f3_11; <$SEL extends "1", $KIND extends "i2f3">(): (after: (v1: U1, v2: U2, v3: U3) => R) => converge_i2f3_10; <$SEL extends "01", $KIND extends "i2f3">(): (_after: PH, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3]) => converge_i2f3_01; - <$SEL extends "11", $KIND extends "i2f4">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4]) => converge_i2f4_11; + <$SEL extends "11", $KIND extends "i2f4">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4]) => converge_i2f4_11; <$SEL extends "1", $KIND extends "i2f4">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R) => converge_i2f4_10; <$SEL extends "01", $KIND extends "i2f4">(): (_after: PH, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4]) => converge_i2f4_01; - <$SEL extends "11", $KIND extends "i2f5">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5]) => converge_i2f5_11; + <$SEL extends "11", $KIND extends "i2f5">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5]) => converge_i2f5_11; <$SEL extends "1", $KIND extends "i2f5">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R) => converge_i2f5_10; <$SEL extends "01", $KIND extends "i2f5">(): (_after: PH, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5]) => converge_i2f5_01; - <$SEL extends "11", $KIND extends "i2f6">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5, (v1: T1, v2: T2) => U6]) => converge_i2f6_11; + <$SEL extends "11", $KIND extends "i2f6">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5, (v1: T1, v2: T2) => U6]) => converge_i2f6_11; <$SEL extends "1", $KIND extends "i2f6">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R) => converge_i2f6_10; <$SEL extends "01", $KIND extends "i2f6">(): (_after: PH, fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5, (v1: T1, v2: T2) => U6]) => converge_i2f6_01; - <$SEL extends "11", $KIND extends "i3f1">(): (after: (v1: U1) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1]) => converge_i3f1_11; + <$SEL extends "11", $KIND extends "i3f1">(): (after: (v1: U1) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1]) => converge_i3f1_11; <$SEL extends "1", $KIND extends "i3f1">(): (after: (v1: U1) => R) => converge_i3f1_10; <$SEL extends "01", $KIND extends "i3f1">(): (_after: PH, fns: [(v1: T1, v2: T2, v3: T3) => U1]) => converge_i3f1_01; - <$SEL extends "11", $KIND extends "i3f2">(): (after: (v1: U1, v2: U2) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2]) => converge_i3f2_11; + <$SEL extends "11", $KIND extends "i3f2">(): (after: (v1: U1, v2: U2) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2]) => converge_i3f2_11; <$SEL extends "1", $KIND extends "i3f2">(): (after: (v1: U1, v2: U2) => R) => converge_i3f2_10; <$SEL extends "01", $KIND extends "i3f2">(): (_after: PH, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2]) => converge_i3f2_01; - <$SEL extends "11", $KIND extends "i3f3">(): (after: (v1: U1, v2: U2, v3: U3) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3]) => converge_i3f3_11; + <$SEL extends "11", $KIND extends "i3f3">(): (after: (v1: U1, v2: U2, v3: U3) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3]) => converge_i3f3_11; <$SEL extends "1", $KIND extends "i3f3">(): (after: (v1: U1, v2: U2, v3: U3) => R) => converge_i3f3_10; <$SEL extends "01", $KIND extends "i3f3">(): (_after: PH, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3]) => converge_i3f3_01; - <$SEL extends "11", $KIND extends "i3f4">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4]) => converge_i3f4_11; + <$SEL extends "11", $KIND extends "i3f4">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4]) => converge_i3f4_11; <$SEL extends "1", $KIND extends "i3f4">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R) => converge_i3f4_10; <$SEL extends "01", $KIND extends "i3f4">(): (_after: PH, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4]) => converge_i3f4_01; - <$SEL extends "11", $KIND extends "i3f5">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5]) => converge_i3f5_11; + <$SEL extends "11", $KIND extends "i3f5">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5]) => converge_i3f5_11; <$SEL extends "1", $KIND extends "i3f5">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R) => converge_i3f5_10; <$SEL extends "01", $KIND extends "i3f5">(): (_after: PH, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5]) => converge_i3f5_01; - <$SEL extends "11", $KIND extends "i3f6">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5, (v1: T1, v2: T2, v3: T3) => U6]) => converge_i3f6_11; + <$SEL extends "11", $KIND extends "i3f6">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5, (v1: T1, v2: T2, v3: T3) => U6]) => converge_i3f6_11; <$SEL extends "1", $KIND extends "i3f6">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R) => converge_i3f6_10; <$SEL extends "01", $KIND extends "i3f6">(): (_after: PH, fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5, (v1: T1, v2: T2, v3: T3) => U6]) => converge_i3f6_01; <$SEL extends "11", $KIND extends "variadic">(): (after: Variadic, fns: List>) => converge_variadic_11; @@ -146,136 +146,136 @@ type converge_00 = { (after: Variadic): converge_variadic_10; }; type converge_i1f1_10 = { - (fns: [(v1: T1) => U1]): converge_i1f1_11; + (fns: [(v1: T1) => U1]): converge_i1f1_11; }; type converge_i1f2_10 = { - (fns: [(v1: T1) => U1, (v1: T1) => U2]): converge_i1f2_11; + (fns: [(v1: T1) => U1, (v1: T1) => U2]): converge_i1f2_11; }; type converge_i1f3_10 = { - (fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3]): converge_i1f3_11; + (fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3]): converge_i1f3_11; }; type converge_i1f4_10 = { - (fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4]): converge_i1f4_11; + (fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4]): converge_i1f4_11; }; type converge_i1f5_10 = { - (fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5]): converge_i1f5_11; + (fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5]): converge_i1f5_11; }; type converge_i1f6_10 = { - (fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5, (v1: T1) => U6]): converge_i1f6_11; + (fns: [(v1: T1) => U1, (v1: T1) => U2, (v1: T1) => U3, (v1: T1) => U4, (v1: T1) => U5, (v1: T1) => U6]): converge_i1f6_11; }; type converge_i2f1_10 = { - (fns: [(v1: T1, v2: T2) => U1]): converge_i2f1_11; + (fns: [(v1: T1, v2: T2) => U1]): converge_i2f1_11; }; type converge_i2f2_10 = { - (fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2]): converge_i2f2_11; + (fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2]): converge_i2f2_11; }; type converge_i2f3_10 = { - (fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3]): converge_i2f3_11; + (fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3]): converge_i2f3_11; }; type converge_i2f4_10 = { - (fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4]): converge_i2f4_11; + (fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4]): converge_i2f4_11; }; type converge_i2f5_10 = { - (fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5]): converge_i2f5_11; + (fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5]): converge_i2f5_11; }; type converge_i2f6_10 = { - (fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5, (v1: T1, v2: T2) => U6]): converge_i2f6_11; + (fns: [(v1: T1, v2: T2) => U1, (v1: T1, v2: T2) => U2, (v1: T1, v2: T2) => U3, (v1: T1, v2: T2) => U4, (v1: T1, v2: T2) => U5, (v1: T1, v2: T2) => U6]): converge_i2f6_11; }; type converge_i3f1_10 = { - (fns: [(v1: T1, v2: T2, v3: T3) => U1]): converge_i3f1_11; + (fns: [(v1: T1, v2: T2, v3: T3) => U1]): converge_i3f1_11; }; type converge_i3f2_10 = { - (fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2]): converge_i3f2_11; + (fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2]): converge_i3f2_11; }; type converge_i3f3_10 = { - (fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3]): converge_i3f3_11; + (fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3]): converge_i3f3_11; }; type converge_i3f4_10 = { - (fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4]): converge_i3f4_11; + (fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4]): converge_i3f4_11; }; type converge_i3f5_10 = { - (fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5]): converge_i3f5_11; + (fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5]): converge_i3f5_11; }; type converge_i3f6_10 = { - (fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5, (v1: T1, v2: T2, v3: T3) => U6]): converge_i3f6_11; + (fns: [(v1: T1, v2: T2, v3: T3) => U1, (v1: T1, v2: T2, v3: T3) => U2, (v1: T1, v2: T2, v3: T3) => U3, (v1: T1, v2: T2, v3: T3) => U4, (v1: T1, v2: T2, v3: T3) => U5, (v1: T1, v2: T2, v3: T3) => U6]): converge_i3f6_11; }; type converge_variadic_10 = { (fns: List>): converge_variadic_11; }; type converge_i1f1_01 = { - (after: (v1: U1) => R): converge_i1f1_11; + (after: (v1: U1) => R): converge_i1f1_11; }; type converge_i1f2_01 = { - (after: (v1: U1, v2: U2) => R): converge_i1f2_11; + (after: (v1: U1, v2: U2) => R): converge_i1f2_11; }; type converge_i1f3_01 = { - (after: (v1: U1, v2: U2, v3: U3) => R): converge_i1f3_11; + (after: (v1: U1, v2: U2, v3: U3) => R): converge_i1f3_11; }; type converge_i1f4_01 = { - (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R): converge_i1f4_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R): converge_i1f4_11; }; type converge_i1f5_01 = { - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R): converge_i1f5_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R): converge_i1f5_11; }; type converge_i1f6_01 = { - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R): converge_i1f6_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R): converge_i1f6_11; }; type converge_i2f1_01 = { - (after: (v1: U1) => R): converge_i2f1_11; + (after: (v1: U1) => R): converge_i2f1_11; }; type converge_i2f2_01 = { - (after: (v1: U1, v2: U2) => R): converge_i2f2_11; + (after: (v1: U1, v2: U2) => R): converge_i2f2_11; }; type converge_i2f3_01 = { - (after: (v1: U1, v2: U2, v3: U3) => R): converge_i2f3_11; + (after: (v1: U1, v2: U2, v3: U3) => R): converge_i2f3_11; }; type converge_i2f4_01 = { - (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R): converge_i2f4_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R): converge_i2f4_11; }; type converge_i2f5_01 = { - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R): converge_i2f5_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R): converge_i2f5_11; }; type converge_i2f6_01 = { - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R): converge_i2f6_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R): converge_i2f6_11; }; type converge_i3f1_01 = { - (after: (v1: U1) => R): converge_i3f1_11; + (after: (v1: U1) => R): converge_i3f1_11; }; type converge_i3f2_01 = { - (after: (v1: U1, v2: U2) => R): converge_i3f2_11; + (after: (v1: U1, v2: U2) => R): converge_i3f2_11; }; type converge_i3f3_01 = { - (after: (v1: U1, v2: U2, v3: U3) => R): converge_i3f3_11; + (after: (v1: U1, v2: U2, v3: U3) => R): converge_i3f3_11; }; type converge_i3f4_01 = { - (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R): converge_i3f4_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R): converge_i3f4_11; }; type converge_i3f5_01 = { - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R): converge_i3f5_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R): converge_i3f5_11; }; type converge_i3f6_01 = { - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R): converge_i3f6_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R): converge_i3f6_11; }; type converge_variadic_01 = { (after: Variadic): converge_variadic_11; }; -type converge_i1f1_11 = CurriedFunction1; -type converge_i1f2_11 = CurriedFunction1; -type converge_i1f3_11 = CurriedFunction1; -type converge_i1f4_11 = CurriedFunction1; -type converge_i1f5_11 = CurriedFunction1; -type converge_i1f6_11 = CurriedFunction1; -type converge_i2f1_11 = CurriedFunction2; -type converge_i2f2_11 = CurriedFunction2; -type converge_i2f3_11 = CurriedFunction2; -type converge_i2f4_11 = CurriedFunction2; -type converge_i2f5_11 = CurriedFunction2; -type converge_i2f6_11 = CurriedFunction2; -type converge_i3f1_11 = CurriedFunction3; -type converge_i3f2_11 = CurriedFunction3; -type converge_i3f3_11 = CurriedFunction3; -type converge_i3f4_11 = CurriedFunction3; -type converge_i3f5_11 = CurriedFunction3; -type converge_i3f6_11 = CurriedFunction3; +type converge_i1f1_11 = CurriedFunction1; +type converge_i1f2_11 = CurriedFunction1; +type converge_i1f3_11 = CurriedFunction1; +type converge_i1f4_11 = CurriedFunction1; +type converge_i1f5_11 = CurriedFunction1; +type converge_i1f6_11 = CurriedFunction1; +type converge_i2f1_11 = CurriedFunction2; +type converge_i2f2_11 = CurriedFunction2; +type converge_i2f3_11 = CurriedFunction2; +type converge_i2f4_11 = CurriedFunction2; +type converge_i2f5_11 = CurriedFunction2; +type converge_i2f6_11 = CurriedFunction2; +type converge_i3f1_11 = CurriedFunction3; +type converge_i3f2_11 = CurriedFunction3; +type converge_i3f3_11 = CurriedFunction3; +type converge_i3f4_11 = CurriedFunction3; +type converge_i3f5_11 = CurriedFunction3; +type converge_i3f6_11 = CurriedFunction3; type converge_variadic_11 = Variadic; export = converge; diff --git a/ramda/dist/src/countBy.d.ts b/ramda/dist/src/countBy.d.ts index 4753042..53bb29e 100644 --- a/ramda/dist/src/countBy.d.ts +++ b/ramda/dist/src/countBy.d.ts @@ -27,17 +27,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const countBy: countBy_00; type countBy_00 = { (_fn: PH, list: List): countBy_01; - (fn: Morphism, list: List): countBy_11; - <$SEL extends "11">(): (fn: Morphism, list: List) => countBy_11; + (fn: Morphism, list: List): countBy_11; + <$SEL extends "11">(): (fn: Morphism, list: List) => countBy_11; <$SEL extends "1">(): (fn: Morphism) => countBy_10; <$SEL extends "01">(): (_fn: PH, list: List) => countBy_01; (fn: Morphism): countBy_10; }; type countBy_10 = { - (list: List): countBy_11; + (list: List): countBy_11; }; type countBy_01 = { - (fn: Morphism): countBy_11; + (fn: Morphism): countBy_11; }; -type countBy_11 = Dictionary; +type countBy_11 = Dictionary; export = countBy; diff --git a/ramda/dist/src/descend.d.ts b/ramda/dist/src/descend.d.ts index 91b846a..5745ae7 100644 --- a/ramda/dist/src/descend.d.ts +++ b/ramda/dist/src/descend.d.ts @@ -27,10 +27,10 @@ type descend_000 = { (fn: Morphism, _a: PH, b: T): descend_101; (_fn: PH, a: T, b: T): descend_011; (_fn: PH, _a: PH, b: T): descend_001; - (fn: Morphism, a: T, b: T): descend_111; + (fn: Morphism, a: T, b: T): descend_111; (_fn: PH, a: T): descend_010; (fn: Morphism, a: T): descend_110; - <$SEL extends "111">(): (fn: Morphism, a: T, b: T) => descend_111; + <$SEL extends "111">(): (fn: Morphism, a: T, b: T) => descend_111; <$SEL extends "11">(): (fn: Morphism, a: T) => descend_110; <$SEL extends "101">(): (fn: Morphism, _a: PH, b: T) => descend_101; <$SEL extends "1">(): (fn: Morphism) => descend_100; @@ -41,36 +41,36 @@ type descend_000 = { }; type descend_100 = { (_a: PH, b: T): descend_101; - (a: T, b: T): descend_111; - <$SEL extends "11">(): (a: T, b: T) => descend_111; + (a: T, b: T): descend_111; + <$SEL extends "11">(): (a: T, b: T) => descend_111; <$SEL extends "1">(): (a: T) => descend_110; <$SEL extends "01">(): (_a: PH, b: T) => descend_101; (a: T): descend_110; }; type descend_010 = { (_fn: PH, b: T): descend_011; - (fn: Morphism, b: T): descend_111; - <$SEL extends "11">(): (fn: Morphism, b: T) => descend_111; + (fn: Morphism, b: T): descend_111; + <$SEL extends "11">(): (fn: Morphism, b: T) => descend_111; <$SEL extends "1">(): (fn: Morphism) => descend_110; <$SEL extends "01">(): (_fn: PH, b: T) => descend_011; (fn: Morphism): descend_110; }; type descend_110 = { - (b: T): descend_111; + (b: T): descend_111; }; type descend_001 = { (_fn: PH, a: T): descend_011; - (fn: Morphism, a: T): descend_111; - <$SEL extends "11">(): (fn: Morphism, a: T) => descend_111; + (fn: Morphism, a: T): descend_111; + <$SEL extends "11">(): (fn: Morphism, a: T) => descend_111; <$SEL extends "1">(): (fn: Morphism) => descend_101; <$SEL extends "01">(): (_fn: PH, a: T) => descend_011; (fn: Morphism): descend_101; }; type descend_101 = { - (a: T): descend_111; + (a: T): descend_111; }; type descend_011 = { - (fn: Morphism): descend_111; + (fn: Morphism): descend_111; }; -type descend_111 = number; +type descend_111 = number; export = descend; diff --git a/ramda/dist/src/empty.d.ts b/ramda/dist/src/empty.d.ts index 32d524d..c887029 100644 --- a/ramda/dist/src/empty.d.ts +++ b/ramda/dist/src/empty.d.ts @@ -26,10 +26,10 @@ type empty_0 = { (container: string): empty_string_1; <$SEL extends "1", $KIND extends "array">(): (container: T[]) => empty_array_1; <$SEL extends "1", $KIND extends "string">(): (container: string) => empty_string_1; - <$SEL extends "1", $KIND extends "manual">(): (container: U) => empty_manual_1; - (container: U): empty_manual_1; + <$SEL extends "1", $KIND extends "manual">(): (container: U) => empty_manual_1; + (container: U): empty_manual_1; }; type empty_array_1 = T[]; type empty_string_1 = string; -type empty_manual_1 = R; +type empty_manual_1 = R; export = empty; diff --git a/ramda/dist/src/endsWith.d.ts b/ramda/dist/src/endsWith.d.ts index 484834c..ba09957 100644 --- a/ramda/dist/src/endsWith.d.ts +++ b/ramda/dist/src/endsWith.d.ts @@ -22,17 +22,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const endsWith: endsWith_00; type endsWith_00 = { >(_suffix: PH, list: T): endsWith_01; - >(suffix: T, list: T): endsWith_11; - <$SEL extends "11">(): >(suffix: T, list: T) => endsWith_11; + >(suffix: T, list: T): endsWith_11; + <$SEL extends "11">(): >(suffix: T, list: T) => endsWith_11; <$SEL extends "1">(): >(suffix: T) => endsWith_10; <$SEL extends "01">(): >(_suffix: PH, list: T) => endsWith_01; >(suffix: T): endsWith_10; }; type endsWith_10> = { - (list: T): endsWith_11; + (list: T): endsWith_11; }; type endsWith_01> = { - (suffix: T): endsWith_11; + (suffix: T): endsWith_11; }; -type endsWith_11> = boolean; +type endsWith_11 = boolean; export = endsWith; diff --git a/ramda/dist/src/eqBy.d.ts b/ramda/dist/src/eqBy.d.ts index f39fce0..73f5f1e 100644 --- a/ramda/dist/src/eqBy.d.ts +++ b/ramda/dist/src/eqBy.d.ts @@ -22,10 +22,10 @@ type eqBy_000 = { (fn: Morphism, _a: PH, b: T): eqBy_101; (_fn: PH, a: T, b: T): eqBy_011; (_fn: PH, _a: PH, b: T): eqBy_001; - (fn: Morphism, a: T, b: T): eqBy_111; + (fn: Morphism, a: T, b: T): eqBy_111; (_fn: PH, a: T): eqBy_010; (fn: Morphism, a: T): eqBy_110; - <$SEL extends "111">(): (fn: Morphism, a: T, b: T) => eqBy_111; + <$SEL extends "111">(): (fn: Morphism, a: T, b: T) => eqBy_111; <$SEL extends "11">(): (fn: Morphism, a: T) => eqBy_110; <$SEL extends "101">(): (fn: Morphism, _a: PH, b: T) => eqBy_101; <$SEL extends "1">(): (fn: Morphism) => eqBy_100; @@ -36,36 +36,36 @@ type eqBy_000 = { }; type eqBy_100 = { (_a: PH, b: T): eqBy_101; - (a: T, b: T): eqBy_111; - <$SEL extends "11">(): (a: T, b: T) => eqBy_111; + (a: T, b: T): eqBy_111; + <$SEL extends "11">(): (a: T, b: T) => eqBy_111; <$SEL extends "1">(): (a: T) => eqBy_110; <$SEL extends "01">(): (_a: PH, b: T) => eqBy_101; (a: T): eqBy_110; }; type eqBy_010 = { (_fn: PH, b: T): eqBy_011; - (fn: Morphism, b: T): eqBy_111; - <$SEL extends "11">(): (fn: Morphism, b: T) => eqBy_111; + (fn: Morphism, b: T): eqBy_111; + <$SEL extends "11">(): (fn: Morphism, b: T) => eqBy_111; <$SEL extends "1">(): (fn: Morphism) => eqBy_110; <$SEL extends "01">(): (_fn: PH, b: T) => eqBy_011; (fn: Morphism): eqBy_110; }; type eqBy_110 = { - (b: T): eqBy_111; + (b: T): eqBy_111; }; type eqBy_001 = { (_fn: PH, a: T): eqBy_011; - (fn: Morphism, a: T): eqBy_111; - <$SEL extends "11">(): (fn: Morphism, a: T) => eqBy_111; + (fn: Morphism, a: T): eqBy_111; + <$SEL extends "11">(): (fn: Morphism, a: T) => eqBy_111; <$SEL extends "1">(): (fn: Morphism) => eqBy_101; <$SEL extends "01">(): (_fn: PH, a: T) => eqBy_011; (fn: Morphism): eqBy_101; }; type eqBy_101 = { - (a: T): eqBy_111; + (a: T): eqBy_111; }; type eqBy_011 = { - (fn: Morphism): eqBy_111; + (fn: Morphism): eqBy_111; }; -type eqBy_111 = boolean; +type eqBy_111 = boolean; export = eqBy; diff --git a/ramda/dist/src/eqProps.d.ts b/ramda/dist/src/eqProps.d.ts index 1c884b2..b0c9adb 100644 --- a/ramda/dist/src/eqProps.d.ts +++ b/ramda/dist/src/eqProps.d.ts @@ -26,10 +26,10 @@ type eqProps_000 = { (property: Property, _a: PH, b: T): eqProps_101; (_property: PH, a: T, b: T): eqProps_011; (_property: PH, _a: PH, b: T): eqProps_001; - (property: Property, a: T, b: T): eqProps_111; + (property: Property, a: T, b: T): eqProps_111; (_property: PH, a: T): eqProps_010; (property: Property, a: T): eqProps_110; - <$SEL extends "111">(): (property: Property, a: T, b: T) => eqProps_111; + <$SEL extends "111">(): (property: Property, a: T, b: T) => eqProps_111; <$SEL extends "11">(): (property: Property, a: T) => eqProps_110; <$SEL extends "101">(): (property: Property, _a: PH, b: T) => eqProps_101; <$SEL extends "1">(): (property: Property) => eqProps_100; @@ -40,36 +40,36 @@ type eqProps_000 = { }; type eqProps_100 = { (_a: PH, b: T): eqProps_101; - (a: T, b: T): eqProps_111; - <$SEL extends "11">(): (a: T, b: T) => eqProps_111; + (a: T, b: T): eqProps_111; + <$SEL extends "11">(): (a: T, b: T) => eqProps_111; <$SEL extends "1">(): (a: T) => eqProps_110; <$SEL extends "01">(): (_a: PH, b: T) => eqProps_101; (a: T): eqProps_110; }; type eqProps_010 = { (_property: PH, b: T): eqProps_011; - (property: Property, b: T): eqProps_111; - <$SEL extends "11">(): (property: Property, b: T) => eqProps_111; + (property: Property, b: T): eqProps_111; + <$SEL extends "11">(): (property: Property, b: T) => eqProps_111; <$SEL extends "1">(): (property: Property) => eqProps_110; <$SEL extends "01">(): (_property: PH, b: T) => eqProps_011; (property: Property): eqProps_110; }; type eqProps_110 = { - (b: T): eqProps_111; + (b: T): eqProps_111; }; type eqProps_001 = { (_property: PH, a: T): eqProps_011; - (property: Property, a: T): eqProps_111; - <$SEL extends "11">(): (property: Property, a: T) => eqProps_111; + (property: Property, a: T): eqProps_111; + <$SEL extends "11">(): (property: Property, a: T) => eqProps_111; <$SEL extends "1">(): (property: Property) => eqProps_101; <$SEL extends "01">(): (_property: PH, a: T) => eqProps_011; (property: Property): eqProps_101; }; type eqProps_101 = { - (a: T): eqProps_111; + (a: T): eqProps_111; }; type eqProps_011 = { - (property: Property): eqProps_111; + (property: Property): eqProps_111; }; -type eqProps_111 = boolean; +type eqProps_111 = boolean; export = eqProps; diff --git a/ramda/dist/src/equals.d.ts b/ramda/dist/src/equals.d.ts index 0372142..5ffa19c 100644 --- a/ramda/dist/src/equals.d.ts +++ b/ramda/dist/src/equals.d.ts @@ -27,17 +27,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const equals: equals_00; type equals_00 = { (_a: PH, b: T): equals_01; - (a: T, b: T): equals_11; - <$SEL extends "11">(): (a: T, b: T) => equals_11; + (a: T, b: T): equals_11; + <$SEL extends "11">(): (a: T, b: T) => equals_11; <$SEL extends "1">(): (a: T) => equals_10; <$SEL extends "01">(): (_a: PH, b: T) => equals_01; (a: T): equals_10; }; type equals_10 = { - (b: T): equals_11; + (b: T): equals_11; }; type equals_01 = { - (a: T): equals_11; + (a: T): equals_11; }; -type equals_11 = boolean; +type equals_11 = boolean; export = equals; diff --git a/ramda/dist/src/findIndex.d.ts b/ramda/dist/src/findIndex.d.ts index 0f2bb22..5a4f508 100644 --- a/ramda/dist/src/findIndex.d.ts +++ b/ramda/dist/src/findIndex.d.ts @@ -25,17 +25,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const findIndex: findIndex_00; type findIndex_00 = { (_fn: PH, list: List): findIndex_01; - (fn: Predicate, list: List): findIndex_11; - <$SEL extends "11">(): (fn: Predicate, list: List) => findIndex_11; + (fn: Predicate, list: List): findIndex_11; + <$SEL extends "11">(): (fn: Predicate, list: List) => findIndex_11; <$SEL extends "1">(): (fn: Predicate) => findIndex_10; <$SEL extends "01">(): (_fn: PH, list: List) => findIndex_01; (fn: Predicate): findIndex_10; }; type findIndex_10 = { - (list: List): findIndex_11; + (list: List): findIndex_11; }; type findIndex_01 = { - (fn: Predicate): findIndex_11; + (fn: Predicate): findIndex_11; }; -type findIndex_11 = number; +type findIndex_11 = number; export = findIndex; diff --git a/ramda/dist/src/findLastIndex.d.ts b/ramda/dist/src/findLastIndex.d.ts index 2d84476..710a89e 100644 --- a/ramda/dist/src/findLastIndex.d.ts +++ b/ramda/dist/src/findLastIndex.d.ts @@ -25,17 +25,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const findLastIndex: findLastIndex_00; type findLastIndex_00 = { (_fn: PH, list: List): findLastIndex_01; - (fn: Predicate, list: List): findLastIndex_11; - <$SEL extends "11">(): (fn: Predicate, list: List) => findLastIndex_11; + (fn: Predicate, list: List): findLastIndex_11; + <$SEL extends "11">(): (fn: Predicate, list: List) => findLastIndex_11; <$SEL extends "1">(): (fn: Predicate) => findLastIndex_10; <$SEL extends "01">(): (_fn: PH, list: List) => findLastIndex_01; (fn: Predicate): findLastIndex_10; }; type findLastIndex_10 = { - (list: List): findLastIndex_11; + (list: List): findLastIndex_11; }; type findLastIndex_01 = { - (fn: Predicate): findLastIndex_11; + (fn: Predicate): findLastIndex_11; }; -type findLastIndex_11 = number; +type findLastIndex_11 = number; export = findLastIndex; diff --git a/ramda/dist/src/gt.d.ts b/ramda/dist/src/gt.d.ts index 612dfe1..c5c1833 100644 --- a/ramda/dist/src/gt.d.ts +++ b/ramda/dist/src/gt.d.ts @@ -24,17 +24,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const gt: gt_00; type gt_00 = { (_a: PH, b: T): gt_01; - (a: T, b: T): gt_11; - <$SEL extends "11">(): (a: T, b: T) => gt_11; + (a: T, b: T): gt_11; + <$SEL extends "11">(): (a: T, b: T) => gt_11; <$SEL extends "1">(): (a: T) => gt_10; <$SEL extends "01">(): (_a: PH, b: T) => gt_01; (a: T): gt_10; }; type gt_10 = { - (b: T): gt_11; + (b: T): gt_11; }; type gt_01 = { - (a: T): gt_11; + (a: T): gt_11; }; -type gt_11 = boolean; +type gt_11 = boolean; export = gt; diff --git a/ramda/dist/src/gte.d.ts b/ramda/dist/src/gte.d.ts index c339c70..2dc918e 100644 --- a/ramda/dist/src/gte.d.ts +++ b/ramda/dist/src/gte.d.ts @@ -24,17 +24,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const gte: gte_00; type gte_00 = { (_a: PH, b: T): gte_01; - (a: T, b: T): gte_11; - <$SEL extends "11">(): (a: T, b: T) => gte_11; + (a: T, b: T): gte_11; + <$SEL extends "11">(): (a: T, b: T) => gte_11; <$SEL extends "1">(): (a: T) => gte_10; <$SEL extends "01">(): (_a: PH, b: T) => gte_01; (a: T): gte_10; }; type gte_10 = { - (b: T): gte_11; + (b: T): gte_11; }; type gte_01 = { - (a: T): gte_11; + (a: T): gte_11; }; -type gte_11 = boolean; +type gte_11 = boolean; export = gte; diff --git a/ramda/dist/src/has.d.ts b/ramda/dist/src/has.d.ts index 1f79edc..f78c3a0 100644 --- a/ramda/dist/src/has.d.ts +++ b/ramda/dist/src/has.d.ts @@ -27,17 +27,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const has: has_00; type has_00 = { (_property: PH, object: T): has_01; - (property: Property, object: T): has_11; - <$SEL extends "11">(): (property: Property, object: T) => has_11; + (property: Property, object: T): has_11; + <$SEL extends "11">(): (property: Property, object: T) => has_11; <$SEL extends "1">(): (property: Property) => has_10; <$SEL extends "01">(): (_property: PH, object: T) => has_01; (property: Property): has_10; }; type has_10 = { - (object: T): has_11; + (object: T): has_11; }; type has_01 = { - (property: Property): has_11; + (property: Property): has_11; }; -type has_11 = boolean; +type has_11 = boolean; export = has; diff --git a/ramda/dist/src/hasIn.d.ts b/ramda/dist/src/hasIn.d.ts index a989051..ed21319 100644 --- a/ramda/dist/src/hasIn.d.ts +++ b/ramda/dist/src/hasIn.d.ts @@ -29,17 +29,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const hasIn: hasIn_00; type hasIn_00 = { (_property: PH, object: T): hasIn_01; - (property: Property, object: T): hasIn_11; - <$SEL extends "11">(): (property: Property, object: T) => hasIn_11; + (property: Property, object: T): hasIn_11; + <$SEL extends "11">(): (property: Property, object: T) => hasIn_11; <$SEL extends "1">(): (property: Property) => hasIn_10; <$SEL extends "01">(): (_property: PH, object: T) => hasIn_01; (property: Property): hasIn_10; }; type hasIn_10 = { - (object: T): hasIn_11; + (object: T): hasIn_11; }; type hasIn_01 = { - (property: Property): hasIn_11; + (property: Property): hasIn_11; }; -type hasIn_11 = boolean; +type hasIn_11 = boolean; export = hasIn; diff --git a/ramda/dist/src/identical.d.ts b/ramda/dist/src/identical.d.ts index 6c766d9..0e832df 100644 --- a/ramda/dist/src/identical.d.ts +++ b/ramda/dist/src/identical.d.ts @@ -25,17 +25,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const identical: identical_00; type identical_00 = { (_a: PH, b: T): identical_01; - (a: T, b: T): identical_11; - <$SEL extends "11">(): (a: T, b: T) => identical_11; + (a: T, b: T): identical_11; + <$SEL extends "11">(): (a: T, b: T) => identical_11; <$SEL extends "1">(): (a: T) => identical_10; <$SEL extends "01">(): (_a: PH, b: T) => identical_01; (a: T): identical_10; }; type identical_10 = { - (b: T): identical_11; + (b: T): identical_11; }; type identical_01 = { - (a: T): identical_11; + (a: T): identical_11; }; -type identical_11 = boolean; +type identical_11 = boolean; export = identical; diff --git a/ramda/dist/src/indexOf.d.ts b/ramda/dist/src/indexOf.d.ts index 9a26eed..3afbbba 100644 --- a/ramda/dist/src/indexOf.d.ts +++ b/ramda/dist/src/indexOf.d.ts @@ -22,17 +22,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const indexOf: indexOf_00; type indexOf_00 = { (_target: PH, list: List): indexOf_01; - (target: T, list: List): indexOf_11; - <$SEL extends "11">(): (target: T, list: List) => indexOf_11; + (target: T, list: List): indexOf_11; + <$SEL extends "11">(): (target: T, list: List) => indexOf_11; <$SEL extends "1">(): (target: T) => indexOf_10; <$SEL extends "01">(): (_target: PH, list: List) => indexOf_01; (target: T): indexOf_10; }; type indexOf_10 = { - (list: List): indexOf_11; + (list: List): indexOf_11; }; type indexOf_01 = { - (target: T): indexOf_11; + (target: T): indexOf_11; }; -type indexOf_11 = number; +type indexOf_11 = number; export = indexOf; diff --git a/ramda/dist/src/innerJoin.d.ts b/ramda/dist/src/innerJoin.d.ts index fba34ca..bb58f2c 100644 --- a/ramda/dist/src/innerJoin.d.ts +++ b/ramda/dist/src/innerJoin.d.ts @@ -40,10 +40,10 @@ type innerJoin_000 = { (pred: (a: T, b: U) => boolean, _xs: PH, ys: List): innerJoin_101; (_pred: PH, xs: List, ys: List): innerJoin_011; (_pred: PH, _xs: PH, ys: List): innerJoin_001; - (pred: (a: T, b: U) => boolean, xs: List, ys: List): innerJoin_111; + (pred: (a: T, b: U) => boolean, xs: List, ys: List): innerJoin_111; (_pred: PH, xs: List): innerJoin_010; (pred: (a: T, b: U) => boolean, xs: List): innerJoin_110; - <$SEL extends "111">(): (pred: (a: T, b: U) => boolean, xs: List, ys: List) => innerJoin_111; + <$SEL extends "111">(): (pred: (a: T, b: U) => boolean, xs: List, ys: List) => innerJoin_111; <$SEL extends "11">(): (pred: (a: T, b: U) => boolean, xs: List) => innerJoin_110; <$SEL extends "101">(): (pred: (a: T, b: U) => boolean, _xs: PH, ys: List) => innerJoin_101; <$SEL extends "1">(): (pred: (a: T, b: U) => boolean) => innerJoin_100; @@ -54,36 +54,36 @@ type innerJoin_000 = { }; type innerJoin_100 = { (_xs: PH, ys: List): innerJoin_101; - (xs: List, ys: List): innerJoin_111; - <$SEL extends "11">(): (xs: List, ys: List) => innerJoin_111; + (xs: List, ys: List): innerJoin_111; + <$SEL extends "11">(): (xs: List, ys: List) => innerJoin_111; <$SEL extends "1">(): (xs: List) => innerJoin_110; <$SEL extends "01">(): (_xs: PH, ys: List) => innerJoin_101; (xs: List): innerJoin_110; }; type innerJoin_010 = { (_pred: PH, ys: List): innerJoin_011; - (pred: (a: T, b: U) => boolean, ys: List): innerJoin_111; - <$SEL extends "11">(): (pred: (a: T, b: U) => boolean, ys: List) => innerJoin_111; + (pred: (a: T, b: U) => boolean, ys: List): innerJoin_111; + <$SEL extends "11">(): (pred: (a: T, b: U) => boolean, ys: List) => innerJoin_111; <$SEL extends "1">(): (pred: (a: T, b: U) => boolean) => innerJoin_110; <$SEL extends "01">(): (_pred: PH, ys: List) => innerJoin_011; (pred: (a: T, b: U) => boolean): innerJoin_110; }; type innerJoin_110 = { - (ys: List): innerJoin_111; + (ys: List): innerJoin_111; }; type innerJoin_001 = { (_pred: PH, xs: List): innerJoin_011; - (pred: (a: T, b: U) => boolean, xs: List): innerJoin_111; - <$SEL extends "11">(): (pred: (a: T, b: U) => boolean, xs: List) => innerJoin_111; + (pred: (a: T, b: U) => boolean, xs: List): innerJoin_111; + <$SEL extends "11">(): (pred: (a: T, b: U) => boolean, xs: List) => innerJoin_111; <$SEL extends "1">(): (pred: (a: T, b: U) => boolean) => innerJoin_101; <$SEL extends "01">(): (_pred: PH, xs: List) => innerJoin_011; (pred: (a: T, b: U) => boolean): innerJoin_101; }; type innerJoin_101 = { - (xs: List): innerJoin_111; + (xs: List): innerJoin_111; }; type innerJoin_011 = { - (pred: (a: T, b: U) => boolean): innerJoin_111; + (pred: (a: T, b: U) => boolean): innerJoin_111; }; -type innerJoin_111 = T[]; +type innerJoin_111 = T[]; export = innerJoin; diff --git a/ramda/dist/src/into.d.ts b/ramda/dist/src/into.d.ts index fb3996c..67df6d9 100644 --- a/ramda/dist/src/into.d.ts +++ b/ramda/dist/src/into.d.ts @@ -45,20 +45,20 @@ type into_000 = { (_initial: PH, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced), values: T[]): into_transformer_011; (_initial: PH, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced), values: T[]): into_base_011; (_initial: PH, _transducer: PH, values: T[]): into_001; - (initial: Transformer, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced), values: T[]): into_transformer_111; - (initial: V, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced), values: T[]): into_base_111; + (initial: Transformer, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced), values: T[]): into_transformer_111; + (initial: V, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced), values: T[]): into_base_111; (_initial: PH, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)): into_transformer_010; (_initial: PH, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced)): into_base_010; (initial: Transformer, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)): into_transformer_110; (initial: V, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced)): into_base_110; (initial: Transformer): into_transformer_100; - <$SEL extends "111", $KIND extends "transformer">(): (initial: Transformer, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced), values: T[]) => into_transformer_111; + <$SEL extends "111", $KIND extends "transformer">(): (initial: Transformer, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced), values: T[]) => into_transformer_111; <$SEL extends "11", $KIND extends "transformer">(): (initial: Transformer, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)) => into_transformer_110; <$SEL extends "101", $KIND extends "transformer">(): (initial: Transformer, _transducer: PH, values: T[]) => into_transformer_101; <$SEL extends "1", $KIND extends "transformer">(): (initial: Transformer) => into_transformer_100; <$SEL extends "011", $KIND extends "transformer">(): (_initial: PH, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced), values: T[]) => into_transformer_011; <$SEL extends "01", $KIND extends "transformer">(): (_initial: PH, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)) => into_transformer_010; - <$SEL extends "111", $KIND extends "base">(): (initial: V, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced), values: T[]) => into_base_111; + <$SEL extends "111", $KIND extends "base">(): (initial: V, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced), values: T[]) => into_base_111; <$SEL extends "11", $KIND extends "base">(): (initial: V, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced)) => into_base_110; <$SEL extends "101", $KIND extends "base">(): (initial: V, _transducer: PH, values: T[]) => into_base_101; <$SEL extends "1", $KIND extends "base">(): (initial: V) => into_base_100; @@ -70,67 +70,67 @@ type into_000 = { type into_001 = { (_initial: PH, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)): into_transformer_011; (_initial: PH, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced)): into_base_011; - (initial: Transformer, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)): into_transformer_111; - (initial: V, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced)): into_base_111; + (initial: Transformer, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)): into_transformer_111; + (initial: V, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced)): into_base_111; (initial: Transformer): into_transformer_101; - <$SEL extends "11", $KIND extends "transformer">(): (initial: Transformer, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)) => into_transformer_111; + <$SEL extends "11", $KIND extends "transformer">(): (initial: Transformer, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)) => into_transformer_111; <$SEL extends "1", $KIND extends "transformer">(): (initial: Transformer) => into_transformer_101; <$SEL extends "01", $KIND extends "transformer">(): (_initial: PH, transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)) => into_transformer_011; - <$SEL extends "11", $KIND extends "base">(): (initial: V, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced)) => into_base_111; + <$SEL extends "11", $KIND extends "base">(): (initial: V, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced)) => into_base_111; <$SEL extends "1", $KIND extends "base">(): (initial: V) => into_base_101; <$SEL extends "01", $KIND extends "base">(): (_initial: PH, transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced)) => into_base_011; (initial: V): into_base_101; }; type into_transformer_100 = { (_transducer: PH, values: T[]): into_transformer_101; - (transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced), values: T[]): into_transformer_111; - <$SEL extends "11">(): (transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced), values: T[]) => into_transformer_111; + (transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced), values: T[]): into_transformer_111; + <$SEL extends "11">(): (transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced), values: T[]) => into_transformer_111; <$SEL extends "1">(): (transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)) => into_transformer_110; <$SEL extends "01">(): (_transducer: PH, values: T[]) => into_transformer_101; (transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)): into_transformer_110; }; type into_base_100 = { (_transducer: PH, values: T[]): into_base_101; - (transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced), values: T[]): into_base_111; - <$SEL extends "11">(): (transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced), values: T[]) => into_base_111; + (transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced), values: T[]): into_base_111; + <$SEL extends "11">(): (transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced), values: T[]) => into_base_111; <$SEL extends "1">(): (transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced)) => into_base_110; <$SEL extends "01">(): (_transducer: PH, values: T[]) => into_base_101; (transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced)): into_base_110; }; type into_transformer_010 = { (_initial: PH, values: T[]): into_transformer_011; - (initial: Transformer, values: T[]): into_transformer_111; - <$SEL extends "11">(): (initial: Transformer, values: T[]) => into_transformer_111; + (initial: Transformer, values: T[]): into_transformer_111; + <$SEL extends "11">(): (initial: Transformer, values: T[]) => into_transformer_111; <$SEL extends "1">(): (initial: Transformer) => into_transformer_110; <$SEL extends "01">(): (_initial: PH, values: T[]) => into_transformer_011; (initial: Transformer): into_transformer_110; }; type into_base_010 = { (_initial: PH, values: T[]): into_base_011; - (initial: V, values: T[]): into_base_111; - <$SEL extends "11">(): (initial: V, values: T[]) => into_base_111; + (initial: V, values: T[]): into_base_111; + <$SEL extends "11">(): (initial: V, values: T[]) => into_base_111; <$SEL extends "1">(): (initial: V) => into_base_110; <$SEL extends "01">(): (_initial: PH, values: T[]) => into_base_011; (initial: V): into_base_110; }; type into_transformer_110 = { - (values: T[]): into_transformer_111; + (values: T[]): into_transformer_111; }; type into_base_110 = { - (values: T[]): into_base_111; + (values: T[]): into_base_111; }; type into_transformer_101 = { - (transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)): into_transformer_111; + (transducer: Morphism | ((transformer: Transformer) => (accumulator: U, value: T) => U | Reduced)): into_transformer_111; }; type into_base_101 = { - (transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced)): into_base_111; + (transducer: Morphism | ((transformer: Transformer) => (accumulator: V, value: T) => V | Reduced)): into_base_111; }; type into_transformer_011 = { - (initial: Transformer): into_transformer_111; + (initial: Transformer): into_transformer_111; }; type into_base_011 = { - (initial: V): into_base_111; + (initial: V): into_base_111; }; -type into_transformer_111 = U; -type into_base_111 = V; +type into_transformer_111 = U; +type into_base_111 = V; export = into; diff --git a/ramda/dist/src/invoker.d.ts b/ramda/dist/src/invoker.d.ts index c26d205..dddfbf5 100644 --- a/ramda/dist/src/invoker.d.ts +++ b/ramda/dist/src/invoker.d.ts @@ -37,7 +37,7 @@ type invoker_00 = { , T1, T2, T3, R>(arity: 3, method: N): invoker_3arity_11; , T1, T2, T3, T4, R>(arity: 4, method: N): invoker_4arity_11; , T1, T2, T3, T4, T5, R>(arity: 5, method: N): invoker_5arity_11; - (arity: number, method: N): invoker_variadic_11; + (arity: number, method: N): invoker_variadic_11; (arity: 0): invoker_0arity_10; (arity: 1): invoker_1arity_10; (arity: 2): invoker_2arity_10; @@ -56,7 +56,7 @@ type invoker_00 = { <$SEL extends "1", $KIND extends "4arity">(): (arity: 4) => invoker_4arity_10; <$SEL extends "11", $KIND extends "5arity">(): , T1, T2, T3, T4, T5, R>(arity: 5, method: N) => invoker_5arity_11; <$SEL extends "1", $KIND extends "5arity">(): (arity: 5) => invoker_5arity_10; - <$SEL extends "11", $KIND extends "variadic">(): (arity: number, method: N) => invoker_variadic_11; + <$SEL extends "11", $KIND extends "variadic">(): (arity: number, method: N) => invoker_variadic_11; <$SEL extends "1", $KIND extends "variadic">(): (arity: number) => invoker_variadic_10; <$SEL extends "01">(): (_arity: PH, method: N) => invoker_01; (arity: number): invoker_variadic_10; @@ -74,8 +74,8 @@ type invoker_01 = { <$SEL extends "1", $KIND extends "3arity">(): , T1, T2, T3, R>(arity: 3) => invoker_3arity_11; <$SEL extends "1", $KIND extends "4arity">(): , T1, T2, T3, T4, R>(arity: 4) => invoker_4arity_11; <$SEL extends "1", $KIND extends "5arity">(): , T1, T2, T3, T4, T5, R>(arity: 5) => invoker_5arity_11; - <$SEL extends "1", $KIND extends "variadic">(): (arity: number) => invoker_variadic_11; - (arity: number): invoker_variadic_11; + <$SEL extends "1", $KIND extends "variadic">(): (arity: number) => invoker_variadic_11; + (arity: number): invoker_variadic_11; }; type invoker_0arity_10 = { , R>(method: N): invoker_0arity_11; @@ -96,7 +96,7 @@ type invoker_5arity_10 = { , T1, T2, T3, T4, T5, R>(method: N): invoker_5arity_11; }; type invoker_variadic_10 = { - (method: N): invoker_variadic_11; + (method: N): invoker_variadic_11; }; type invoker_0arity_11, R> = CurriedFunction1; type invoker_1arity_11, T1, R> = CurriedFunction2; @@ -104,5 +104,5 @@ type invoker_2arity_11, T1, T2, type invoker_3arity_11, T1, T2, T3, R> = CurriedFunction4; type invoker_4arity_11, T1, T2, T3, T4, R> = CurriedFunction5; type invoker_5arity_11, T1, T2, T3, T4, T5, R> = CurriedFunction6; -type invoker_variadic_11 = Variadic; +type invoker_variadic_11 = Variadic; export = invoker; diff --git a/ramda/dist/src/lastIndexOf.d.ts b/ramda/dist/src/lastIndexOf.d.ts index 7300d26..d45e629 100644 --- a/ramda/dist/src/lastIndexOf.d.ts +++ b/ramda/dist/src/lastIndexOf.d.ts @@ -22,17 +22,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const lastIndexOf: lastIndexOf_00; type lastIndexOf_00 = { (_target: PH, list: List): lastIndexOf_01; - (target: T, list: List): lastIndexOf_11; - <$SEL extends "11">(): (target: T, list: List) => lastIndexOf_11; + (target: T, list: List): lastIndexOf_11; + <$SEL extends "11">(): (target: T, list: List) => lastIndexOf_11; <$SEL extends "1">(): (target: T) => lastIndexOf_10; <$SEL extends "01">(): (_target: PH, list: List) => lastIndexOf_01; (target: T): lastIndexOf_10; }; type lastIndexOf_10 = { - (list: List): lastIndexOf_11; + (list: List): lastIndexOf_11; }; type lastIndexOf_01 = { - (target: T): lastIndexOf_11; + (target: T): lastIndexOf_11; }; -type lastIndexOf_11 = number; +type lastIndexOf_11 = number; export = lastIndexOf; diff --git a/ramda/dist/src/lt.d.ts b/ramda/dist/src/lt.d.ts index 2592203..1dc0e60 100644 --- a/ramda/dist/src/lt.d.ts +++ b/ramda/dist/src/lt.d.ts @@ -24,17 +24,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const lt: lt_00; type lt_00 = { (_a: PH, b: T): lt_01; - (a: T, b: T): lt_11; - <$SEL extends "11">(): (a: T, b: T) => lt_11; + (a: T, b: T): lt_11; + <$SEL extends "11">(): (a: T, b: T) => lt_11; <$SEL extends "1">(): (a: T) => lt_10; <$SEL extends "01">(): (_a: PH, b: T) => lt_01; (a: T): lt_10; }; type lt_10 = { - (b: T): lt_11; + (b: T): lt_11; }; type lt_01 = { - (a: T): lt_11; + (a: T): lt_11; }; -type lt_11 = boolean; +type lt_11 = boolean; export = lt; diff --git a/ramda/dist/src/lte.d.ts b/ramda/dist/src/lte.d.ts index 2ab406c..a8bdeae 100644 --- a/ramda/dist/src/lte.d.ts +++ b/ramda/dist/src/lte.d.ts @@ -24,17 +24,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const lte: lte_00; type lte_00 = { (_a: PH, b: T): lte_01; - (a: T, b: T): lte_11; - <$SEL extends "11">(): (a: T, b: T) => lte_11; + (a: T, b: T): lte_11; + <$SEL extends "11">(): (a: T, b: T) => lte_11; <$SEL extends "1">(): (a: T) => lte_10; <$SEL extends "01">(): (_a: PH, b: T) => lte_01; (a: T): lte_10; }; type lte_10 = { - (b: T): lte_11; + (b: T): lte_11; }; type lte_01 = { - (a: T): lte_11; + (a: T): lte_11; }; -type lte_11 = boolean; +type lte_11 = boolean; export = lte; diff --git a/ramda/dist/src/map.d.ts b/ramda/dist/src/map.d.ts index fc7ca83..58eed43 100644 --- a/ramda/dist/src/map.d.ts +++ b/ramda/dist/src/map.d.ts @@ -40,36 +40,36 @@ type map_00 = { (_fn: PH, list: List): map_list_01; (_fn: PH, functor: Functor): map_functor_01; (_fn: PH, object: Record): map_object_01; - (fn: Morphism, list: List): map_list_11; - (fn: Morphism, functor: Functor): map_functor_11; - (fn: Morphism, object: Record): map_object_11; - <$SEL extends "11", $KIND extends "list">(): (fn: Morphism, list: List) => map_list_11; + (fn: Morphism, list: List): map_list_11; + (fn: Morphism, functor: Functor): map_functor_11; + (fn: Morphism, object: Record): map_object_11; + <$SEL extends "11", $KIND extends "list">(): (fn: Morphism, list: List) => map_list_11; <$SEL extends "01", $KIND extends "list">(): (_fn: PH, list: List) => map_list_01; - <$SEL extends "11", $KIND extends "functor">(): (fn: Morphism, functor: Functor) => map_functor_11; + <$SEL extends "11", $KIND extends "functor">(): (fn: Morphism, functor: Functor) => map_functor_11; <$SEL extends "01", $KIND extends "functor">(): (_fn: PH, functor: Functor) => map_functor_01; - <$SEL extends "11", $KIND extends "object">(): (fn: Morphism, object: Record) => map_object_11; + <$SEL extends "11", $KIND extends "object">(): (fn: Morphism, object: Record) => map_object_11; <$SEL extends "01", $KIND extends "object">(): (_fn: PH, object: Record) => map_object_01; <$SEL extends "1">(): (fn: Morphism) => map_10; (fn: Morphism): map_10; }; type map_10 = { - (list: List): map_list_11; - (functor: Functor): map_functor_11; - <$SEL extends "1", $KIND extends "list">(): (list: List) => map_list_11; - <$SEL extends "1", $KIND extends "functor">(): (functor: Functor) => map_functor_11; - <$SEL extends "1", $KIND extends "object">(): (object: Record) => map_object_11; - (object: Record): map_object_11; + (list: List): map_list_11; + (functor: Functor): map_functor_11; + <$SEL extends "1", $KIND extends "list">(): (list: List) => map_list_11; + <$SEL extends "1", $KIND extends "functor">(): (functor: Functor) => map_functor_11; + <$SEL extends "1", $KIND extends "object">(): (object: Record) => map_object_11; + (object: Record): map_object_11; }; type map_list_01 = { - (fn: Morphism): map_list_11; + (fn: Morphism): map_list_11; }; type map_functor_01 = { - (fn: Morphism): map_functor_11; + (fn: Morphism): map_functor_11; }; type map_object_01 = { - (fn: Morphism): map_object_11; + (fn: Morphism): map_object_11; }; -type map_list_11 = U[]; -type map_functor_11 = Functor; -type map_object_11 = Record; +type map_list_11 = U[]; +type map_functor_11 = Functor; +type map_object_11 = Record; export = map; diff --git a/ramda/dist/src/mapAccum.d.ts b/ramda/dist/src/mapAccum.d.ts index b4d3bf9..ecd3e9f 100644 --- a/ramda/dist/src/mapAccum.d.ts +++ b/ramda/dist/src/mapAccum.d.ts @@ -39,10 +39,10 @@ type mapAccum_000 = { (fn: (accumulator: U, value: T) => [U, R], _initial: PH, list: List): mapAccum_101; (_fn: PH, initial: U, list: List): mapAccum_011; (_fn: PH, _initial: PH, list: List): mapAccum_001; - (fn: (accumulator: U, value: T) => [U, R], initial: U, list: List): mapAccum_111; + (fn: (accumulator: U, value: T) => [U, R], initial: U, list: List): mapAccum_111; (_fn: PH, initial: U): mapAccum_010; (fn: (accumulator: U, value: T) => [U, R], initial: U): mapAccum_110; - <$SEL extends "111">(): (fn: (accumulator: U, value: T) => [U, R], initial: U, list: List) => mapAccum_111; + <$SEL extends "111">(): (fn: (accumulator: U, value: T) => [U, R], initial: U, list: List) => mapAccum_111; <$SEL extends "11">(): (fn: (accumulator: U, value: T) => [U, R], initial: U) => mapAccum_110; <$SEL extends "101">(): (fn: (accumulator: U, value: T) => [U, R], _initial: PH, list: List) => mapAccum_101; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => [U, R]) => mapAccum_100; @@ -53,36 +53,36 @@ type mapAccum_000 = { }; type mapAccum_100 = { (_initial: PH, list: List): mapAccum_101; - (initial: U, list: List): mapAccum_111; - <$SEL extends "11">(): (initial: U, list: List) => mapAccum_111; + (initial: U, list: List): mapAccum_111; + <$SEL extends "11">(): (initial: U, list: List) => mapAccum_111; <$SEL extends "1">(): (initial: U) => mapAccum_110; <$SEL extends "01">(): (_initial: PH, list: List) => mapAccum_101; (initial: U): mapAccum_110; }; type mapAccum_010 = { (_fn: PH, list: List): mapAccum_011; - (fn: (accumulator: U, value: T) => [U, R], list: List): mapAccum_111; - <$SEL extends "11">(): (fn: (accumulator: U, value: T) => [U, R], list: List) => mapAccum_111; + (fn: (accumulator: U, value: T) => [U, R], list: List): mapAccum_111; + <$SEL extends "11">(): (fn: (accumulator: U, value: T) => [U, R], list: List) => mapAccum_111; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => [U, R]) => mapAccum_110; <$SEL extends "01">(): (_fn: PH, list: List) => mapAccum_011; (fn: (accumulator: U, value: T) => [U, R]): mapAccum_110; }; type mapAccum_110 = { - (list: List): mapAccum_111; + (list: List): mapAccum_111; }; type mapAccum_001 = { (_fn: PH, initial: U): mapAccum_011; - (fn: (accumulator: U, value: T) => [U, R], initial: U): mapAccum_111; - <$SEL extends "11">(): (fn: (accumulator: U, value: T) => [U, R], initial: U) => mapAccum_111; + (fn: (accumulator: U, value: T) => [U, R], initial: U): mapAccum_111; + <$SEL extends "11">(): (fn: (accumulator: U, value: T) => [U, R], initial: U) => mapAccum_111; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => [U, R]) => mapAccum_101; <$SEL extends "01">(): (_fn: PH, initial: U) => mapAccum_011; (fn: (accumulator: U, value: T) => [U, R]): mapAccum_101; }; type mapAccum_101 = { - (initial: U): mapAccum_111; + (initial: U): mapAccum_111; }; type mapAccum_011 = { - (fn: (accumulator: U, value: T) => [U, R]): mapAccum_111; + (fn: (accumulator: U, value: T) => [U, R]): mapAccum_111; }; -type mapAccum_111 = [U, R[]]; +type mapAccum_111 = [U, R[]]; export = mapAccum; diff --git a/ramda/dist/src/mapAccumRight.d.ts b/ramda/dist/src/mapAccumRight.d.ts index 669b653..f3e1ddb 100644 --- a/ramda/dist/src/mapAccumRight.d.ts +++ b/ramda/dist/src/mapAccumRight.d.ts @@ -42,10 +42,10 @@ type mapAccumRight_000 = { (fn: (value: T, accumulator: U) => [R, U], _initial: PH, list: List): mapAccumRight_101; (_fn: PH, initial: U, list: List): mapAccumRight_011; (_fn: PH, _initial: PH, list: List): mapAccumRight_001; - (fn: (value: T, accumulator: U) => [R, U], initial: U, list: List): mapAccumRight_111; + (fn: (value: T, accumulator: U) => [R, U], initial: U, list: List): mapAccumRight_111; (_fn: PH, initial: U): mapAccumRight_010; (fn: (value: T, accumulator: U) => [R, U], initial: U): mapAccumRight_110; - <$SEL extends "111">(): (fn: (value: T, accumulator: U) => [R, U], initial: U, list: List) => mapAccumRight_111; + <$SEL extends "111">(): (fn: (value: T, accumulator: U) => [R, U], initial: U, list: List) => mapAccumRight_111; <$SEL extends "11">(): (fn: (value: T, accumulator: U) => [R, U], initial: U) => mapAccumRight_110; <$SEL extends "101">(): (fn: (value: T, accumulator: U) => [R, U], _initial: PH, list: List) => mapAccumRight_101; <$SEL extends "1">(): (fn: (value: T, accumulator: U) => [R, U]) => mapAccumRight_100; @@ -56,36 +56,36 @@ type mapAccumRight_000 = { }; type mapAccumRight_100 = { (_initial: PH, list: List): mapAccumRight_101; - (initial: U, list: List): mapAccumRight_111; - <$SEL extends "11">(): (initial: U, list: List) => mapAccumRight_111; + (initial: U, list: List): mapAccumRight_111; + <$SEL extends "11">(): (initial: U, list: List) => mapAccumRight_111; <$SEL extends "1">(): (initial: U) => mapAccumRight_110; <$SEL extends "01">(): (_initial: PH, list: List) => mapAccumRight_101; (initial: U): mapAccumRight_110; }; type mapAccumRight_010 = { (_fn: PH, list: List): mapAccumRight_011; - (fn: (value: T, accumulator: U) => [R, U], list: List): mapAccumRight_111; - <$SEL extends "11">(): (fn: (value: T, accumulator: U) => [R, U], list: List) => mapAccumRight_111; + (fn: (value: T, accumulator: U) => [R, U], list: List): mapAccumRight_111; + <$SEL extends "11">(): (fn: (value: T, accumulator: U) => [R, U], list: List) => mapAccumRight_111; <$SEL extends "1">(): (fn: (value: T, accumulator: U) => [R, U]) => mapAccumRight_110; <$SEL extends "01">(): (_fn: PH, list: List) => mapAccumRight_011; (fn: (value: T, accumulator: U) => [R, U]): mapAccumRight_110; }; type mapAccumRight_110 = { - (list: List): mapAccumRight_111; + (list: List): mapAccumRight_111; }; type mapAccumRight_001 = { (_fn: PH, initial: U): mapAccumRight_011; - (fn: (value: T, accumulator: U) => [R, U], initial: U): mapAccumRight_111; - <$SEL extends "11">(): (fn: (value: T, accumulator: U) => [R, U], initial: U) => mapAccumRight_111; + (fn: (value: T, accumulator: U) => [R, U], initial: U): mapAccumRight_111; + <$SEL extends "11">(): (fn: (value: T, accumulator: U) => [R, U], initial: U) => mapAccumRight_111; <$SEL extends "1">(): (fn: (value: T, accumulator: U) => [R, U]) => mapAccumRight_101; <$SEL extends "01">(): (_fn: PH, initial: U) => mapAccumRight_011; (fn: (value: T, accumulator: U) => [R, U]): mapAccumRight_101; }; type mapAccumRight_101 = { - (initial: U): mapAccumRight_111; + (initial: U): mapAccumRight_111; }; type mapAccumRight_011 = { - (fn: (value: T, accumulator: U) => [R, U]): mapAccumRight_111; + (fn: (value: T, accumulator: U) => [R, U]): mapAccumRight_111; }; -type mapAccumRight_111 = [R[], U]; +type mapAccumRight_111 = [R[], U]; export = mapAccumRight; diff --git a/ramda/dist/src/mapObjIndexed.d.ts b/ramda/dist/src/mapObjIndexed.d.ts index be00e16..901db29 100644 --- a/ramda/dist/src/mapObjIndexed.d.ts +++ b/ramda/dist/src/mapObjIndexed.d.ts @@ -24,17 +24,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const mapObjIndexed: mapObjIndexed_00; type mapObjIndexed_00 = { (_fn: PH, object: Record): mapObjIndexed_01; - (fn: KeyedObjectMorphism, object: Record): mapObjIndexed_11; - <$SEL extends "11">(): (fn: KeyedObjectMorphism, object: Record) => mapObjIndexed_11; + (fn: KeyedObjectMorphism, object: Record): mapObjIndexed_11; + <$SEL extends "11">(): (fn: KeyedObjectMorphism, object: Record) => mapObjIndexed_11; <$SEL extends "1">(): (fn: KeyedObjectMorphism) => mapObjIndexed_10; <$SEL extends "01">(): (_fn: PH, object: Record) => mapObjIndexed_01; (fn: KeyedObjectMorphism): mapObjIndexed_10; }; type mapObjIndexed_10 = { - (object: Record): mapObjIndexed_11; + (object: Record): mapObjIndexed_11; }; type mapObjIndexed_01 = { - (fn: KeyedObjectMorphism): mapObjIndexed_11; + (fn: KeyedObjectMorphism): mapObjIndexed_11; }; -type mapObjIndexed_11 = Record; +type mapObjIndexed_11 = Record; export = mapObjIndexed; diff --git a/ramda/dist/src/mergeDeepWith.d.ts b/ramda/dist/src/mergeDeepWith.d.ts index 765f9d5..81da31b 100644 --- a/ramda/dist/src/mergeDeepWith.d.ts +++ b/ramda/dist/src/mergeDeepWith.d.ts @@ -31,10 +31,10 @@ type mergeDeepWith_000 = { (fn: (a: V, b: V) => any, _left: PH, right: object): mergeDeepWith_101; (_fn: PH, left: object, right: object): mergeDeepWith_011; (_fn: PH, _left: PH, right: object): mergeDeepWith_001; - (fn: (a: V, b: V) => any, left: object, right: object): mergeDeepWith_111; + (fn: (a: V, b: V) => any, left: object, right: object): mergeDeepWith_111; (_fn: PH, left: object): mergeDeepWith_010; (fn: (a: V, b: V) => any, left: object): mergeDeepWith_110; - <$SEL extends "111">(): (fn: (a: V, b: V) => any, left: object, right: object) => mergeDeepWith_111; + <$SEL extends "111">(): (fn: (a: V, b: V) => any, left: object, right: object) => mergeDeepWith_111; <$SEL extends "11">(): (fn: (a: V, b: V) => any, left: object) => mergeDeepWith_110; <$SEL extends "101">(): (fn: (a: V, b: V) => any, _left: PH, right: object) => mergeDeepWith_101; <$SEL extends "1">(): (fn: (a: V, b: V) => any) => mergeDeepWith_100; @@ -45,36 +45,36 @@ type mergeDeepWith_000 = { }; type mergeDeepWith_100 = { (_left: PH, right: object): mergeDeepWith_101; - (left: object, right: object): mergeDeepWith_111; - <$SEL extends "11">(): (left: object, right: object) => mergeDeepWith_111; + (left: object, right: object): mergeDeepWith_111; + <$SEL extends "11">(): (left: object, right: object) => mergeDeepWith_111; <$SEL extends "1">(): (left: object) => mergeDeepWith_110; <$SEL extends "01">(): (_left: PH, right: object) => mergeDeepWith_101; (left: object): mergeDeepWith_110; }; type mergeDeepWith_010 = { (_fn: PH, right: object): mergeDeepWith_011; - (fn: (a: V, b: V) => any, right: object): mergeDeepWith_111; - <$SEL extends "11">(): (fn: (a: V, b: V) => any, right: object) => mergeDeepWith_111; + (fn: (a: V, b: V) => any, right: object): mergeDeepWith_111; + <$SEL extends "11">(): (fn: (a: V, b: V) => any, right: object) => mergeDeepWith_111; <$SEL extends "1">(): (fn: (a: V, b: V) => any) => mergeDeepWith_110; <$SEL extends "01">(): (_fn: PH, right: object) => mergeDeepWith_011; (fn: (a: V, b: V) => any): mergeDeepWith_110; }; type mergeDeepWith_110 = { - (right: object): mergeDeepWith_111; + (right: object): mergeDeepWith_111; }; type mergeDeepWith_001 = { (_fn: PH, left: object): mergeDeepWith_011; - (fn: (a: V, b: V) => any, left: object): mergeDeepWith_111; - <$SEL extends "11">(): (fn: (a: V, b: V) => any, left: object) => mergeDeepWith_111; + (fn: (a: V, b: V) => any, left: object): mergeDeepWith_111; + <$SEL extends "11">(): (fn: (a: V, b: V) => any, left: object) => mergeDeepWith_111; <$SEL extends "1">(): (fn: (a: V, b: V) => any) => mergeDeepWith_101; <$SEL extends "01">(): (_fn: PH, left: object) => mergeDeepWith_011; (fn: (a: V, b: V) => any): mergeDeepWith_101; }; type mergeDeepWith_101 = { - (left: object): mergeDeepWith_111; + (left: object): mergeDeepWith_111; }; type mergeDeepWith_011 = { - (fn: (a: V, b: V) => any): mergeDeepWith_111; + (fn: (a: V, b: V) => any): mergeDeepWith_111; }; -type mergeDeepWith_111 = T; +type mergeDeepWith_111 = T; export = mergeDeepWith; diff --git a/ramda/dist/src/mergeDeepWithKey.d.ts b/ramda/dist/src/mergeDeepWithKey.d.ts index 9b9c31f..3e411d1 100644 --- a/ramda/dist/src/mergeDeepWithKey.d.ts +++ b/ramda/dist/src/mergeDeepWithKey.d.ts @@ -32,10 +32,10 @@ type mergeDeepWithKey_000 = { (fn: (key: string, a: V, b: V) => any, _left: PH, right: object): mergeDeepWithKey_101; (_fn: PH, left: object, right: object): mergeDeepWithKey_011; (_fn: PH, _left: PH, right: object): mergeDeepWithKey_001; - (fn: (key: string, a: V, b: V) => any, left: object, right: object): mergeDeepWithKey_111; + (fn: (key: string, a: V, b: V) => any, left: object, right: object): mergeDeepWithKey_111; (_fn: PH, left: object): mergeDeepWithKey_010; (fn: (key: string, a: V, b: V) => any, left: object): mergeDeepWithKey_110; - <$SEL extends "111">(): (fn: (key: string, a: V, b: V) => any, left: object, right: object) => mergeDeepWithKey_111; + <$SEL extends "111">(): (fn: (key: string, a: V, b: V) => any, left: object, right: object) => mergeDeepWithKey_111; <$SEL extends "11">(): (fn: (key: string, a: V, b: V) => any, left: object) => mergeDeepWithKey_110; <$SEL extends "101">(): (fn: (key: string, a: V, b: V) => any, _left: PH, right: object) => mergeDeepWithKey_101; <$SEL extends "1">(): (fn: (key: string, a: V, b: V) => any) => mergeDeepWithKey_100; @@ -46,36 +46,36 @@ type mergeDeepWithKey_000 = { }; type mergeDeepWithKey_100 = { (_left: PH, right: object): mergeDeepWithKey_101; - (left: object, right: object): mergeDeepWithKey_111; - <$SEL extends "11">(): (left: object, right: object) => mergeDeepWithKey_111; + (left: object, right: object): mergeDeepWithKey_111; + <$SEL extends "11">(): (left: object, right: object) => mergeDeepWithKey_111; <$SEL extends "1">(): (left: object) => mergeDeepWithKey_110; <$SEL extends "01">(): (_left: PH, right: object) => mergeDeepWithKey_101; (left: object): mergeDeepWithKey_110; }; type mergeDeepWithKey_010 = { (_fn: PH, right: object): mergeDeepWithKey_011; - (fn: (key: string, a: V, b: V) => any, right: object): mergeDeepWithKey_111; - <$SEL extends "11">(): (fn: (key: string, a: V, b: V) => any, right: object) => mergeDeepWithKey_111; + (fn: (key: string, a: V, b: V) => any, right: object): mergeDeepWithKey_111; + <$SEL extends "11">(): (fn: (key: string, a: V, b: V) => any, right: object) => mergeDeepWithKey_111; <$SEL extends "1">(): (fn: (key: string, a: V, b: V) => any) => mergeDeepWithKey_110; <$SEL extends "01">(): (_fn: PH, right: object) => mergeDeepWithKey_011; (fn: (key: string, a: V, b: V) => any): mergeDeepWithKey_110; }; type mergeDeepWithKey_110 = { - (right: object): mergeDeepWithKey_111; + (right: object): mergeDeepWithKey_111; }; type mergeDeepWithKey_001 = { (_fn: PH, left: object): mergeDeepWithKey_011; - (fn: (key: string, a: V, b: V) => any, left: object): mergeDeepWithKey_111; - <$SEL extends "11">(): (fn: (key: string, a: V, b: V) => any, left: object) => mergeDeepWithKey_111; + (fn: (key: string, a: V, b: V) => any, left: object): mergeDeepWithKey_111; + <$SEL extends "11">(): (fn: (key: string, a: V, b: V) => any, left: object) => mergeDeepWithKey_111; <$SEL extends "1">(): (fn: (key: string, a: V, b: V) => any) => mergeDeepWithKey_101; <$SEL extends "01">(): (_fn: PH, left: object) => mergeDeepWithKey_011; (fn: (key: string, a: V, b: V) => any): mergeDeepWithKey_101; }; type mergeDeepWithKey_101 = { - (left: object): mergeDeepWithKey_111; + (left: object): mergeDeepWithKey_111; }; type mergeDeepWithKey_011 = { - (fn: (key: string, a: V, b: V) => any): mergeDeepWithKey_111; + (fn: (key: string, a: V, b: V) => any): mergeDeepWithKey_111; }; -type mergeDeepWithKey_111 = T; +type mergeDeepWithKey_111 = T; export = mergeDeepWithKey; diff --git a/ramda/dist/src/mergeWith.d.ts b/ramda/dist/src/mergeWith.d.ts index bb33af5..b1edd37 100644 --- a/ramda/dist/src/mergeWith.d.ts +++ b/ramda/dist/src/mergeWith.d.ts @@ -27,10 +27,10 @@ type mergeWith_000 = { (fn: (a: V, b: V) => any, _left: PH, right: object): mergeWith_101; (_fn: PH, left: object, right: object): mergeWith_011; (_fn: PH, _left: PH, right: object): mergeWith_001; - (fn: (a: V, b: V) => any, left: object, right: object): mergeWith_111; + (fn: (a: V, b: V) => any, left: object, right: object): mergeWith_111; (_fn: PH, left: object): mergeWith_010; (fn: (a: V, b: V) => any, left: object): mergeWith_110; - <$SEL extends "111">(): (fn: (a: V, b: V) => any, left: object, right: object) => mergeWith_111; + <$SEL extends "111">(): (fn: (a: V, b: V) => any, left: object, right: object) => mergeWith_111; <$SEL extends "11">(): (fn: (a: V, b: V) => any, left: object) => mergeWith_110; <$SEL extends "101">(): (fn: (a: V, b: V) => any, _left: PH, right: object) => mergeWith_101; <$SEL extends "1">(): (fn: (a: V, b: V) => any) => mergeWith_100; @@ -41,36 +41,36 @@ type mergeWith_000 = { }; type mergeWith_100 = { (_left: PH, right: object): mergeWith_101; - (left: object, right: object): mergeWith_111; - <$SEL extends "11">(): (left: object, right: object) => mergeWith_111; + (left: object, right: object): mergeWith_111; + <$SEL extends "11">(): (left: object, right: object) => mergeWith_111; <$SEL extends "1">(): (left: object) => mergeWith_110; <$SEL extends "01">(): (_left: PH, right: object) => mergeWith_101; (left: object): mergeWith_110; }; type mergeWith_010 = { (_fn: PH, right: object): mergeWith_011; - (fn: (a: V, b: V) => any, right: object): mergeWith_111; - <$SEL extends "11">(): (fn: (a: V, b: V) => any, right: object) => mergeWith_111; + (fn: (a: V, b: V) => any, right: object): mergeWith_111; + <$SEL extends "11">(): (fn: (a: V, b: V) => any, right: object) => mergeWith_111; <$SEL extends "1">(): (fn: (a: V, b: V) => any) => mergeWith_110; <$SEL extends "01">(): (_fn: PH, right: object) => mergeWith_011; (fn: (a: V, b: V) => any): mergeWith_110; }; type mergeWith_110 = { - (right: object): mergeWith_111; + (right: object): mergeWith_111; }; type mergeWith_001 = { (_fn: PH, left: object): mergeWith_011; - (fn: (a: V, b: V) => any, left: object): mergeWith_111; - <$SEL extends "11">(): (fn: (a: V, b: V) => any, left: object) => mergeWith_111; + (fn: (a: V, b: V) => any, left: object): mergeWith_111; + <$SEL extends "11">(): (fn: (a: V, b: V) => any, left: object) => mergeWith_111; <$SEL extends "1">(): (fn: (a: V, b: V) => any) => mergeWith_101; <$SEL extends "01">(): (_fn: PH, left: object) => mergeWith_011; (fn: (a: V, b: V) => any): mergeWith_101; }; type mergeWith_101 = { - (left: object): mergeWith_111; + (left: object): mergeWith_111; }; type mergeWith_011 = { - (fn: (a: V, b: V) => any): mergeWith_111; + (fn: (a: V, b: V) => any): mergeWith_111; }; -type mergeWith_111 = T; +type mergeWith_111 = T; export = mergeWith; diff --git a/ramda/dist/src/mergeWithKey.d.ts b/ramda/dist/src/mergeWithKey.d.ts index 558fefa..e654c01 100644 --- a/ramda/dist/src/mergeWithKey.d.ts +++ b/ramda/dist/src/mergeWithKey.d.ts @@ -29,10 +29,10 @@ type mergeWithKey_000 = { (fn: (key: string, a: V, b: V) => any, _left: PH, right: object): mergeWithKey_101; (_fn: PH, left: object, right: object): mergeWithKey_011; (_fn: PH, _left: PH, right: object): mergeWithKey_001; - (fn: (key: string, a: V, b: V) => any, left: object, right: object): mergeWithKey_111; + (fn: (key: string, a: V, b: V) => any, left: object, right: object): mergeWithKey_111; (_fn: PH, left: object): mergeWithKey_010; (fn: (key: string, a: V, b: V) => any, left: object): mergeWithKey_110; - <$SEL extends "111">(): (fn: (key: string, a: V, b: V) => any, left: object, right: object) => mergeWithKey_111; + <$SEL extends "111">(): (fn: (key: string, a: V, b: V) => any, left: object, right: object) => mergeWithKey_111; <$SEL extends "11">(): (fn: (key: string, a: V, b: V) => any, left: object) => mergeWithKey_110; <$SEL extends "101">(): (fn: (key: string, a: V, b: V) => any, _left: PH, right: object) => mergeWithKey_101; <$SEL extends "1">(): (fn: (key: string, a: V, b: V) => any) => mergeWithKey_100; @@ -43,36 +43,36 @@ type mergeWithKey_000 = { }; type mergeWithKey_100 = { (_left: PH, right: object): mergeWithKey_101; - (left: object, right: object): mergeWithKey_111; - <$SEL extends "11">(): (left: object, right: object) => mergeWithKey_111; + (left: object, right: object): mergeWithKey_111; + <$SEL extends "11">(): (left: object, right: object) => mergeWithKey_111; <$SEL extends "1">(): (left: object) => mergeWithKey_110; <$SEL extends "01">(): (_left: PH, right: object) => mergeWithKey_101; (left: object): mergeWithKey_110; }; type mergeWithKey_010 = { (_fn: PH, right: object): mergeWithKey_011; - (fn: (key: string, a: V, b: V) => any, right: object): mergeWithKey_111; - <$SEL extends "11">(): (fn: (key: string, a: V, b: V) => any, right: object) => mergeWithKey_111; + (fn: (key: string, a: V, b: V) => any, right: object): mergeWithKey_111; + <$SEL extends "11">(): (fn: (key: string, a: V, b: V) => any, right: object) => mergeWithKey_111; <$SEL extends "1">(): (fn: (key: string, a: V, b: V) => any) => mergeWithKey_110; <$SEL extends "01">(): (_fn: PH, right: object) => mergeWithKey_011; (fn: (key: string, a: V, b: V) => any): mergeWithKey_110; }; type mergeWithKey_110 = { - (right: object): mergeWithKey_111; + (right: object): mergeWithKey_111; }; type mergeWithKey_001 = { (_fn: PH, left: object): mergeWithKey_011; - (fn: (key: string, a: V, b: V) => any, left: object): mergeWithKey_111; - <$SEL extends "11">(): (fn: (key: string, a: V, b: V) => any, left: object) => mergeWithKey_111; + (fn: (key: string, a: V, b: V) => any, left: object): mergeWithKey_111; + <$SEL extends "11">(): (fn: (key: string, a: V, b: V) => any, left: object) => mergeWithKey_111; <$SEL extends "1">(): (fn: (key: string, a: V, b: V) => any) => mergeWithKey_101; <$SEL extends "01">(): (_fn: PH, left: object) => mergeWithKey_011; (fn: (key: string, a: V, b: V) => any): mergeWithKey_101; }; type mergeWithKey_101 = { - (left: object): mergeWithKey_111; + (left: object): mergeWithKey_111; }; type mergeWithKey_011 = { - (fn: (key: string, a: V, b: V) => any): mergeWithKey_111; + (fn: (key: string, a: V, b: V) => any): mergeWithKey_111; }; -type mergeWithKey_111 = T; +type mergeWithKey_111 = T; export = mergeWithKey; diff --git a/ramda/dist/src/none.d.ts b/ramda/dist/src/none.d.ts index 1b3cb7b..3dd6e4a 100644 --- a/ramda/dist/src/none.d.ts +++ b/ramda/dist/src/none.d.ts @@ -25,17 +25,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const none: none_00; type none_00 = { (_fn: PH, list: List): none_01; - (fn: Predicate, list: List): none_11; - <$SEL extends "11">(): (fn: Predicate, list: List) => none_11; + (fn: Predicate, list: List): none_11; + <$SEL extends "11">(): (fn: Predicate, list: List) => none_11; <$SEL extends "1">(): (fn: Predicate) => none_10; <$SEL extends "01">(): (_fn: PH, list: List) => none_01; (fn: Predicate): none_10; }; type none_10 = { - (list: List): none_11; + (list: List): none_11; }; type none_01 = { - (fn: Predicate): none_11; + (fn: Predicate): none_11; }; -type none_11 = boolean; +type none_11 = boolean; export = none; diff --git a/ramda/dist/src/o.d.ts b/ramda/dist/src/o.d.ts index 34d8064..9e66781 100644 --- a/ramda/dist/src/o.d.ts +++ b/ramda/dist/src/o.d.ts @@ -30,10 +30,10 @@ type o_000 = { (a: Morphism, _b: PH, value: T1): o_101; (_a: PH, b: Morphism, value: T1): o_011; (_a: PH, _b: PH, value: T1): o_001; - (a: Morphism, b: Morphism, value: T1): o_111; + (a: Morphism, b: Morphism, value: T1): o_111; (_a: PH, b: Morphism): o_010; (a: Morphism, b: Morphism): o_110; - <$SEL extends "111">(): (a: Morphism, b: Morphism, value: T1) => o_111; + <$SEL extends "111">(): (a: Morphism, b: Morphism, value: T1) => o_111; <$SEL extends "11">(): (a: Morphism, b: Morphism) => o_110; <$SEL extends "101">(): (a: Morphism, _b: PH, value: T1) => o_101; <$SEL extends "1">(): (a: Morphism) => o_100; @@ -44,36 +44,36 @@ type o_000 = { }; type o_100 = { (_b: PH, value: T1): o_101; - (b: Morphism, value: T1): o_111; - <$SEL extends "11">(): (b: Morphism, value: T1) => o_111; + (b: Morphism, value: T1): o_111; + <$SEL extends "11">(): (b: Morphism, value: T1) => o_111; <$SEL extends "1">(): (b: Morphism) => o_110; <$SEL extends "01">(): (_b: PH, value: T1) => o_101; (b: Morphism): o_110; }; type o_010 = { (_a: PH, value: T1): o_011; - (a: Morphism, value: T1): o_111; - <$SEL extends "11">(): (a: Morphism, value: T1) => o_111; + (a: Morphism, value: T1): o_111; + <$SEL extends "11">(): (a: Morphism, value: T1) => o_111; <$SEL extends "1">(): (a: Morphism) => o_110; <$SEL extends "01">(): (_a: PH, value: T1) => o_011; (a: Morphism): o_110; }; type o_110 = { - (value: T1): o_111; + (value: T1): o_111; }; type o_001 = { (_a: PH, b: Morphism): o_011; - (a: Morphism, b: Morphism): o_111; - <$SEL extends "11">(): (a: Morphism, b: Morphism) => o_111; + (a: Morphism, b: Morphism): o_111; + <$SEL extends "11">(): (a: Morphism, b: Morphism) => o_111; <$SEL extends "1">(): (a: Morphism) => o_101; <$SEL extends "01">(): (_a: PH, b: Morphism) => o_011; (a: Morphism): o_101; }; type o_101 = { - (b: Morphism): o_111; + (b: Morphism): o_111; }; type o_011 = { - (a: Morphism): o_111; + (a: Morphism): o_111; }; -type o_111 = R; +type o_111 = R; export = o; diff --git a/ramda/dist/src/over.d.ts b/ramda/dist/src/over.d.ts index aafeaa3..2c4f1b6 100644 --- a/ramda/dist/src/over.d.ts +++ b/ramda/dist/src/over.d.ts @@ -27,10 +27,10 @@ type over_000 = { (lens: Lens, _fn: PH, target: U): over_101; (_lens: PH, fn: Morphism, target: U): over_011; (_lens: PH, _fn: PH, target: U): over_001; - (lens: Lens, fn: Morphism, target: U): over_111; + (lens: Lens, fn: Morphism, target: U): over_111; (_lens: PH, fn: Morphism): over_010; (lens: Lens, fn: Morphism): over_110; - <$SEL extends "111">(): (lens: Lens, fn: Morphism, target: U) => over_111; + <$SEL extends "111">(): (lens: Lens, fn: Morphism, target: U) => over_111; <$SEL extends "11">(): (lens: Lens, fn: Morphism) => over_110; <$SEL extends "101">(): (lens: Lens, _fn: PH, target: U) => over_101; <$SEL extends "1">(): (lens: Lens) => over_100; @@ -41,36 +41,36 @@ type over_000 = { }; type over_100 = { (_fn: PH, target: U): over_101; - (fn: Morphism, target: U): over_111; - <$SEL extends "11">(): (fn: Morphism, target: U) => over_111; + (fn: Morphism, target: U): over_111; + <$SEL extends "11">(): (fn: Morphism, target: U) => over_111; <$SEL extends "1">(): (fn: Morphism) => over_110; <$SEL extends "01">(): (_fn: PH, target: U) => over_101; (fn: Morphism): over_110; }; type over_010 = { (_lens: PH, target: U): over_011; - (lens: Lens, target: U): over_111; - <$SEL extends "11">(): (lens: Lens, target: U) => over_111; + (lens: Lens, target: U): over_111; + <$SEL extends "11">(): (lens: Lens, target: U) => over_111; <$SEL extends "1">(): (lens: Lens) => over_110; <$SEL extends "01">(): (_lens: PH, target: U) => over_011; (lens: Lens): over_110; }; type over_110 = { - (target: U): over_111; + (target: U): over_111; }; type over_001 = { (_lens: PH, fn: Morphism): over_011; - (lens: Lens, fn: Morphism): over_111; - <$SEL extends "11">(): (lens: Lens, fn: Morphism) => over_111; + (lens: Lens, fn: Morphism): over_111; + <$SEL extends "11">(): (lens: Lens, fn: Morphism) => over_111; <$SEL extends "1">(): (lens: Lens) => over_101; <$SEL extends "01">(): (_lens: PH, fn: Morphism) => over_011; (lens: Lens): over_101; }; type over_101 = { - (fn: Morphism): over_111; + (fn: Morphism): over_111; }; type over_011 = { - (lens: Lens): over_111; + (lens: Lens): over_111; }; -type over_111 = U; +type over_111 = U; export = over; diff --git a/ramda/dist/src/pathSatisfies.d.ts b/ramda/dist/src/pathSatisfies.d.ts index d1f2f77..b87ceb2 100644 --- a/ramda/dist/src/pathSatisfies.d.ts +++ b/ramda/dist/src/pathSatisfies.d.ts @@ -24,10 +24,10 @@ type pathSatisfies_000 = { (fn: Predicate, _path: PH, object: any): pathSatisfies_101; (_fn: PH, path: Path, object: any): pathSatisfies_011; (_fn: PH, _path: PH, object: any): pathSatisfies_001; - (fn: Predicate, path: Path, object: any): pathSatisfies_111; + (fn: Predicate, path: Path, object: any): pathSatisfies_111; (_fn: PH, path: Path): pathSatisfies_010; (fn: Predicate, path: Path): pathSatisfies_110; - <$SEL extends "111">(): (fn: Predicate, path: Path, object: any) => pathSatisfies_111; + <$SEL extends "111">(): (fn: Predicate, path: Path, object: any) => pathSatisfies_111; <$SEL extends "11">(): (fn: Predicate, path: Path) => pathSatisfies_110; <$SEL extends "101">(): (fn: Predicate, _path: PH, object: any) => pathSatisfies_101; <$SEL extends "1">(): (fn: Predicate) => pathSatisfies_100; @@ -38,36 +38,36 @@ type pathSatisfies_000 = { }; type pathSatisfies_100 = { (_path: PH, object: any): pathSatisfies_101; - (path: Path, object: any): pathSatisfies_111; - <$SEL extends "11">(): (path: Path, object: any) => pathSatisfies_111; + (path: Path, object: any): pathSatisfies_111; + <$SEL extends "11">(): (path: Path, object: any) => pathSatisfies_111; <$SEL extends "1">(): (path: Path) => pathSatisfies_110; <$SEL extends "01">(): (_path: PH, object: any) => pathSatisfies_101; (path: Path): pathSatisfies_110; }; type pathSatisfies_010 = { (_fn: PH, object: any): pathSatisfies_011; - (fn: Predicate, object: any): pathSatisfies_111; - <$SEL extends "11">(): (fn: Predicate, object: any) => pathSatisfies_111; + (fn: Predicate, object: any): pathSatisfies_111; + <$SEL extends "11">(): (fn: Predicate, object: any) => pathSatisfies_111; <$SEL extends "1">(): (fn: Predicate) => pathSatisfies_110; <$SEL extends "01">(): (_fn: PH, object: any) => pathSatisfies_011; (fn: Predicate): pathSatisfies_110; }; type pathSatisfies_110 = { - (object: any): pathSatisfies_111; + (object: any): pathSatisfies_111; }; type pathSatisfies_001 = { (_fn: PH, path: Path): pathSatisfies_011; - (fn: Predicate, path: Path): pathSatisfies_111; - <$SEL extends "11">(): (fn: Predicate, path: Path) => pathSatisfies_111; + (fn: Predicate, path: Path): pathSatisfies_111; + <$SEL extends "11">(): (fn: Predicate, path: Path) => pathSatisfies_111; <$SEL extends "1">(): (fn: Predicate) => pathSatisfies_101; <$SEL extends "01">(): (_fn: PH, path: Path) => pathSatisfies_011; (fn: Predicate): pathSatisfies_101; }; type pathSatisfies_101 = { - (path: Path): pathSatisfies_111; + (path: Path): pathSatisfies_111; }; type pathSatisfies_011 = { - (fn: Predicate): pathSatisfies_111; + (fn: Predicate): pathSatisfies_111; }; -type pathSatisfies_111 = boolean; +type pathSatisfies_111 = boolean; export = pathSatisfies; diff --git a/ramda/dist/src/propSatisfies.d.ts b/ramda/dist/src/propSatisfies.d.ts index f04ccc5..310f250 100644 --- a/ramda/dist/src/propSatisfies.d.ts +++ b/ramda/dist/src/propSatisfies.d.ts @@ -29,9 +29,9 @@ type propSatisfies_000 = { >(_fn: PH, _key: PH, object: T): propSatisfies_record_001; (_fn: PH, key: Property, object: any): propSatisfies_manual_011; (_fn: PH, _key: PH, object: any): propSatisfies_manual_001; - (fn: Predicate, key: K, object: T): propSatisfies_keyof_111; - >(fn: Predicate, key: K, object: T): propSatisfies_record_111; - (fn: Predicate, key: Property, object: any): propSatisfies_manual_111; + (fn: Predicate, key: K, object: T): propSatisfies_keyof_111; + >(fn: Predicate, key: K, object: T): propSatisfies_record_111; + (fn: Predicate, key: Property, object: any): propSatisfies_manual_111; (_fn: PH, key: K): propSatisfies_keyof_010; (_fn: PH, key: K): propSatisfies_record_010; (_fn: PH, key: Property): propSatisfies_manual_010; @@ -40,21 +40,21 @@ type propSatisfies_000 = { (fn: Predicate, key: Property): propSatisfies_manual_110; (fn: Predicate): propSatisfies_keyof_100; >(fn: Predicate): propSatisfies_record_100; - <$SEL extends "111", $KIND extends "keyof">(): (fn: Predicate, key: K, object: T) => propSatisfies_keyof_111; + <$SEL extends "111", $KIND extends "keyof">(): (fn: Predicate, key: K, object: T) => propSatisfies_keyof_111; <$SEL extends "11", $KIND extends "keyof">(): (fn: Predicate, key: K) => propSatisfies_keyof_110; <$SEL extends "101", $KIND extends "keyof">(): (fn: Predicate, _key: PH, object: T) => propSatisfies_keyof_101; <$SEL extends "1", $KIND extends "keyof">(): (fn: Predicate) => propSatisfies_keyof_100; <$SEL extends "011", $KIND extends "keyof">(): (_fn: PH, key: K, object: T) => propSatisfies_keyof_011; <$SEL extends "01", $KIND extends "keyof">(): (_fn: PH, key: K) => propSatisfies_keyof_010; <$SEL extends "001", $KIND extends "keyof">(): (_fn: PH, _key: PH, object: T) => propSatisfies_keyof_001; - <$SEL extends "111", $KIND extends "record">(): >(fn: Predicate, key: K, object: T) => propSatisfies_record_111; + <$SEL extends "111", $KIND extends "record">(): >(fn: Predicate, key: K, object: T) => propSatisfies_record_111; <$SEL extends "11", $KIND extends "record">(): >(fn: Predicate, key: K) => propSatisfies_record_110; <$SEL extends "101", $KIND extends "record">(): >(fn: Predicate, _key: PH, object: T) => propSatisfies_record_101; <$SEL extends "1", $KIND extends "record">(): >(fn: Predicate) => propSatisfies_record_100; <$SEL extends "011", $KIND extends "record">(): >(_fn: PH, key: K, object: T) => propSatisfies_record_011; <$SEL extends "01", $KIND extends "record">(): (_fn: PH, key: K) => propSatisfies_record_010; <$SEL extends "001", $KIND extends "record">(): >(_fn: PH, _key: PH, object: T) => propSatisfies_record_001; - <$SEL extends "111", $KIND extends "manual">(): (fn: Predicate, key: Property, object: any) => propSatisfies_manual_111; + <$SEL extends "111", $KIND extends "manual">(): (fn: Predicate, key: Property, object: any) => propSatisfies_manual_111; <$SEL extends "11", $KIND extends "manual">(): (fn: Predicate, key: Property) => propSatisfies_manual_110; <$SEL extends "101", $KIND extends "manual">(): (fn: Predicate, _key: PH, object: any) => propSatisfies_manual_101; <$SEL extends "1", $KIND extends "manual">(): (fn: Predicate) => propSatisfies_manual_100; @@ -65,104 +65,104 @@ type propSatisfies_000 = { }; type propSatisfies_keyof_100 = { (_key: PH, object: T): propSatisfies_keyof_101; - (key: K, object: T): propSatisfies_keyof_111; - <$SEL extends "11">(): (key: K, object: T) => propSatisfies_keyof_111; + (key: K, object: T): propSatisfies_keyof_111; + <$SEL extends "11">(): (key: K, object: T) => propSatisfies_keyof_111; <$SEL extends "1">(): (key: K) => propSatisfies_keyof_110; <$SEL extends "01">(): (_key: PH, object: T) => propSatisfies_keyof_101; (key: K): propSatisfies_keyof_110; }; type propSatisfies_record_100> = { (_key: PH, object: T): propSatisfies_record_101; - (key: K, object: T): propSatisfies_record_111; - <$SEL extends "11">(): (key: K, object: T) => propSatisfies_record_111; + (key: K, object: T): propSatisfies_record_111; + <$SEL extends "11">(): (key: K, object: T) => propSatisfies_record_111; <$SEL extends "1">(): (key: K) => propSatisfies_record_110; <$SEL extends "01">(): (_key: PH, object: T) => propSatisfies_record_101; (key: K): propSatisfies_record_110; }; type propSatisfies_manual_100 = { (_key: PH, object: any): propSatisfies_manual_101; - (key: Property, object: any): propSatisfies_manual_111; - <$SEL extends "11">(): (key: Property, object: any) => propSatisfies_manual_111; + (key: Property, object: any): propSatisfies_manual_111; + <$SEL extends "11">(): (key: Property, object: any) => propSatisfies_manual_111; <$SEL extends "1">(): (key: Property) => propSatisfies_manual_110; <$SEL extends "01">(): (_key: PH, object: any) => propSatisfies_manual_101; (key: Property): propSatisfies_manual_110; }; type propSatisfies_keyof_010 = { (_fn: PH, object: T): propSatisfies_keyof_011; - (fn: Predicate, object: T): propSatisfies_keyof_111; - <$SEL extends "11">(): (fn: Predicate, object: T) => propSatisfies_keyof_111; + (fn: Predicate, object: T): propSatisfies_keyof_111; + <$SEL extends "11">(): (fn: Predicate, object: T) => propSatisfies_keyof_111; <$SEL extends "1">(): (fn: Predicate) => propSatisfies_keyof_110; <$SEL extends "01">(): (_fn: PH, object: T) => propSatisfies_keyof_011; (fn: Predicate): propSatisfies_keyof_110; }; type propSatisfies_record_010 = { >(_fn: PH, object: T): propSatisfies_record_011; - >(fn: Predicate, object: T): propSatisfies_record_111; - <$SEL extends "11">(): >(fn: Predicate, object: T) => propSatisfies_record_111; + >(fn: Predicate, object: T): propSatisfies_record_111; + <$SEL extends "11">(): >(fn: Predicate, object: T) => propSatisfies_record_111; <$SEL extends "1">(): >(fn: Predicate) => propSatisfies_record_110; <$SEL extends "01">(): >(_fn: PH, object: T) => propSatisfies_record_011; >(fn: Predicate): propSatisfies_record_110; }; type propSatisfies_manual_010 = { (_fn: PH, object: any): propSatisfies_manual_011; - (fn: Predicate, object: any): propSatisfies_manual_111; - <$SEL extends "11">(): (fn: Predicate, object: any) => propSatisfies_manual_111; + (fn: Predicate, object: any): propSatisfies_manual_111; + <$SEL extends "11">(): (fn: Predicate, object: any) => propSatisfies_manual_111; <$SEL extends "1">(): (fn: Predicate) => propSatisfies_manual_110; <$SEL extends "01">(): (_fn: PH, object: any) => propSatisfies_manual_011; (fn: Predicate): propSatisfies_manual_110; }; type propSatisfies_keyof_110 = { - (object: T): propSatisfies_keyof_111; + (object: T): propSatisfies_keyof_111; }; type propSatisfies_record_110> = { - (object: T): propSatisfies_record_111; + (object: T): propSatisfies_record_111; }; type propSatisfies_manual_110 = { - (object: any): propSatisfies_manual_111; + (object: any): propSatisfies_manual_111; }; type propSatisfies_keyof_001 = { (_fn: PH, key: K): propSatisfies_keyof_011; - (fn: Predicate, key: K): propSatisfies_keyof_111; - <$SEL extends "11">(): (fn: Predicate, key: K) => propSatisfies_keyof_111; + (fn: Predicate, key: K): propSatisfies_keyof_111; + <$SEL extends "11">(): (fn: Predicate, key: K) => propSatisfies_keyof_111; <$SEL extends "1">(): (fn: Predicate) => propSatisfies_keyof_101; <$SEL extends "01">(): (_fn: PH, key: K) => propSatisfies_keyof_011; (fn: Predicate): propSatisfies_keyof_101; }; type propSatisfies_record_001> = { (_fn: PH, key: K): propSatisfies_record_011; - (fn: Predicate, key: K): propSatisfies_record_111; - <$SEL extends "11">(): (fn: Predicate, key: K) => propSatisfies_record_111; + (fn: Predicate, key: K): propSatisfies_record_111; + <$SEL extends "11">(): (fn: Predicate, key: K) => propSatisfies_record_111; <$SEL extends "1">(): (fn: Predicate) => propSatisfies_record_101; <$SEL extends "01">(): (_fn: PH, key: K) => propSatisfies_record_011; (fn: Predicate): propSatisfies_record_101; }; type propSatisfies_manual_001 = { (_fn: PH, key: Property): propSatisfies_manual_011; - (fn: Predicate, key: Property): propSatisfies_manual_111; - <$SEL extends "11">(): (fn: Predicate, key: Property) => propSatisfies_manual_111; + (fn: Predicate, key: Property): propSatisfies_manual_111; + <$SEL extends "11">(): (fn: Predicate, key: Property) => propSatisfies_manual_111; <$SEL extends "1">(): (fn: Predicate) => propSatisfies_manual_101; <$SEL extends "01">(): (_fn: PH, key: Property) => propSatisfies_manual_011; (fn: Predicate): propSatisfies_manual_101; }; type propSatisfies_keyof_101 = { - (key: K): propSatisfies_keyof_111; + (key: K): propSatisfies_keyof_111; }; type propSatisfies_record_101> = { - (key: K): propSatisfies_record_111; + (key: K): propSatisfies_record_111; }; type propSatisfies_manual_101 = { - (key: Property): propSatisfies_manual_111; + (key: Property): propSatisfies_manual_111; }; type propSatisfies_keyof_011 = { - (fn: Predicate): propSatisfies_keyof_111; + (fn: Predicate): propSatisfies_keyof_111; }; type propSatisfies_record_011> = { - (fn: Predicate): propSatisfies_record_111; + (fn: Predicate): propSatisfies_record_111; }; type propSatisfies_manual_011 = { - (fn: Predicate): propSatisfies_manual_111; + (fn: Predicate): propSatisfies_manual_111; }; -type propSatisfies_keyof_111 = boolean; -type propSatisfies_record_111> = boolean; -type propSatisfies_manual_111 = boolean; +type propSatisfies_keyof_111 = boolean; +type propSatisfies_record_111 = boolean; +type propSatisfies_manual_111 = boolean; export = propSatisfies; diff --git a/ramda/dist/src/reduce.d.ts b/ramda/dist/src/reduce.d.ts index 215a553..3576d77 100644 --- a/ramda/dist/src/reduce.d.ts +++ b/ramda/dist/src/reduce.d.ts @@ -51,10 +51,10 @@ type reduce_000 = { (fn: (accumulator: U, value: T) => Reduced | U, _initial: PH, values: List): reduce_101; (_fn: PH, initial: U, values: List): reduce_011; (_fn: PH, _initial: PH, values: List): reduce_001; - (fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List): reduce_111; + (fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List): reduce_111; (_fn: PH, initial: U): reduce_010; (fn: (accumulator: U, value: T) => Reduced | U, initial: U): reduce_110; - <$SEL extends "111">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List) => reduce_111; + <$SEL extends "111">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List) => reduce_111; <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduce_110; <$SEL extends "101">(): (fn: (accumulator: U, value: T) => Reduced | U, _initial: PH, values: List) => reduce_101; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => Reduced | U) => reduce_100; @@ -65,36 +65,36 @@ type reduce_000 = { }; type reduce_100 = { (_initial: PH, values: List): reduce_101; - (initial: U, values: List): reduce_111; - <$SEL extends "11">(): (initial: U, values: List) => reduce_111; + (initial: U, values: List): reduce_111; + <$SEL extends "11">(): (initial: U, values: List) => reduce_111; <$SEL extends "1">(): (initial: U) => reduce_110; <$SEL extends "01">(): (_initial: PH, values: List) => reduce_101; (initial: U): reduce_110; }; type reduce_010 = { (_fn: PH, values: List): reduce_011; - (fn: (accumulator: U, value: T) => Reduced | U, values: List): reduce_111; - <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, values: List) => reduce_111; + (fn: (accumulator: U, value: T) => Reduced | U, values: List): reduce_111; + <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, values: List) => reduce_111; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => Reduced | U) => reduce_110; <$SEL extends "01">(): (_fn: PH, values: List) => reduce_011; (fn: (accumulator: U, value: T) => Reduced | U): reduce_110; }; type reduce_110 = { - (values: List): reduce_111; + (values: List): reduce_111; }; type reduce_001 = { (_fn: PH, initial: U): reduce_011; - (fn: (accumulator: U, value: T) => Reduced | U, initial: U): reduce_111; - <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduce_111; + (fn: (accumulator: U, value: T) => Reduced | U, initial: U): reduce_111; + <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduce_111; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => Reduced | U) => reduce_101; <$SEL extends "01">(): (_fn: PH, initial: U) => reduce_011; (fn: (accumulator: U, value: T) => Reduced | U): reduce_101; }; type reduce_101 = { - (initial: U): reduce_111; + (initial: U): reduce_111; }; type reduce_011 = { - (fn: (accumulator: U, value: T) => Reduced | U): reduce_111; + (fn: (accumulator: U, value: T) => Reduced | U): reduce_111; }; -type reduce_111 = U; +type reduce_111 = U; export = reduce; diff --git a/ramda/dist/src/reduceBy.d.ts b/ramda/dist/src/reduceBy.d.ts index 9db3dbc..3ff0c60 100644 --- a/ramda/dist/src/reduceBy.d.ts +++ b/ramda/dist/src/reduceBy.d.ts @@ -53,14 +53,14 @@ type reduceBy_0000 = { (_valueFn: PH, initial: U, _keyFn: PH, values: List): reduceBy_0101; (_valueFn: PH, _initial: PH, keyFn: Morphism, values: List): reduceBy_0011; (_valueFn: PH, _initial: PH, _keyFn: PH, values: List): reduceBy_0001; - (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, keyFn: Morphism, values: List): reduceBy_1111; + (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, keyFn: Morphism, values: List): reduceBy_1111; (valueFn: (accumulator: U, value: T) => Reduced | U, _initial: PH, keyFn: Morphism): reduceBy_1010; (_valueFn: PH, initial: U, keyFn: Morphism): reduceBy_0110; (_valueFn: PH, _initial: PH, keyFn: Morphism): reduceBy_0010; (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, keyFn: Morphism): reduceBy_1110; (_valueFn: PH, initial: U): reduceBy_0100; (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U): reduceBy_1100; - <$SEL extends "1111">(): (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, keyFn: Morphism, values: List) => reduceBy_1111; + <$SEL extends "1111">(): (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, keyFn: Morphism, values: List) => reduceBy_1111; <$SEL extends "111">(): (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, keyFn: Morphism) => reduceBy_1110; <$SEL extends "1101">(): (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, _keyFn: PH, values: List) => reduceBy_1101; <$SEL extends "11">(): (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduceBy_1100; @@ -81,10 +81,10 @@ type reduceBy_1000 = { (initial: U, _keyFn: PH, values: List): reduceBy_1101; (_initial: PH, keyFn: Morphism, values: List): reduceBy_1011; (_initial: PH, _keyFn: PH, values: List): reduceBy_1001; - (initial: U, keyFn: Morphism, values: List): reduceBy_1111; + (initial: U, keyFn: Morphism, values: List): reduceBy_1111; (_initial: PH, keyFn: Morphism): reduceBy_1010; (initial: U, keyFn: Morphism): reduceBy_1110; - <$SEL extends "111">(): (initial: U, keyFn: Morphism, values: List) => reduceBy_1111; + <$SEL extends "111">(): (initial: U, keyFn: Morphism, values: List) => reduceBy_1111; <$SEL extends "11">(): (initial: U, keyFn: Morphism) => reduceBy_1110; <$SEL extends "101">(): (initial: U, _keyFn: PH, values: List) => reduceBy_1101; <$SEL extends "1">(): (initial: U) => reduceBy_1100; @@ -97,10 +97,10 @@ type reduceBy_0100 = { (valueFn: (accumulator: U, value: T) => Reduced | U, _keyFn: PH, values: List): reduceBy_1101; (_valueFn: PH, keyFn: Morphism, values: List): reduceBy_0111; (_valueFn: PH, _keyFn: PH, values: List): reduceBy_0101; - (valueFn: (accumulator: U, value: T) => Reduced | U, keyFn: Morphism, values: List): reduceBy_1111; + (valueFn: (accumulator: U, value: T) => Reduced | U, keyFn: Morphism, values: List): reduceBy_1111; (_valueFn: PH, keyFn: Morphism): reduceBy_0110; (valueFn: (accumulator: U, value: T) => Reduced | U, keyFn: Morphism): reduceBy_1110; - <$SEL extends "111">(): (valueFn: (accumulator: U, value: T) => Reduced | U, keyFn: Morphism, values: List) => reduceBy_1111; + <$SEL extends "111">(): (valueFn: (accumulator: U, value: T) => Reduced | U, keyFn: Morphism, values: List) => reduceBy_1111; <$SEL extends "11">(): (valueFn: (accumulator: U, value: T) => Reduced | U, keyFn: Morphism) => reduceBy_1110; <$SEL extends "101">(): (valueFn: (accumulator: U, value: T) => Reduced | U, _keyFn: PH, values: List) => reduceBy_1101; <$SEL extends "1">(): (valueFn: (accumulator: U, value: T) => Reduced | U) => reduceBy_1100; @@ -111,8 +111,8 @@ type reduceBy_0100 = { }; type reduceBy_1100 = { (_keyFn: PH, values: List): reduceBy_1101; - (keyFn: Morphism, values: List): reduceBy_1111; - <$SEL extends "11">(): (keyFn: Morphism, values: List) => reduceBy_1111; + (keyFn: Morphism, values: List): reduceBy_1111; + <$SEL extends "11">(): (keyFn: Morphism, values: List) => reduceBy_1111; <$SEL extends "1">(): (keyFn: Morphism) => reduceBy_1110; <$SEL extends "01">(): (_keyFn: PH, values: List) => reduceBy_1101; (keyFn: Morphism): reduceBy_1110; @@ -121,10 +121,10 @@ type reduceBy_0010 = { (valueFn: (accumulator: U, value: T) => Reduced | U, _initial: PH, values: List): reduceBy_1011; (_valueFn: PH, initial: U, values: List): reduceBy_0111; (_valueFn: PH, _initial: PH, values: List): reduceBy_0011; - (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List): reduceBy_1111; + (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List): reduceBy_1111; (_valueFn: PH, initial: U): reduceBy_0110; (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U): reduceBy_1110; - <$SEL extends "111">(): (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List) => reduceBy_1111; + <$SEL extends "111">(): (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List) => reduceBy_1111; <$SEL extends "11">(): (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduceBy_1110; <$SEL extends "101">(): (valueFn: (accumulator: U, value: T) => Reduced | U, _initial: PH, values: List) => reduceBy_1011; <$SEL extends "1">(): (valueFn: (accumulator: U, value: T) => Reduced | U) => reduceBy_1010; @@ -135,31 +135,31 @@ type reduceBy_0010 = { }; type reduceBy_1010 = { (_initial: PH, values: List): reduceBy_1011; - (initial: U, values: List): reduceBy_1111; - <$SEL extends "11">(): (initial: U, values: List) => reduceBy_1111; + (initial: U, values: List): reduceBy_1111; + <$SEL extends "11">(): (initial: U, values: List) => reduceBy_1111; <$SEL extends "1">(): (initial: U) => reduceBy_1110; <$SEL extends "01">(): (_initial: PH, values: List) => reduceBy_1011; (initial: U): reduceBy_1110; }; type reduceBy_0110 = { (_valueFn: PH, values: List): reduceBy_0111; - (valueFn: (accumulator: U, value: T) => Reduced | U, values: List): reduceBy_1111; - <$SEL extends "11">(): (valueFn: (accumulator: U, value: T) => Reduced | U, values: List) => reduceBy_1111; + (valueFn: (accumulator: U, value: T) => Reduced | U, values: List): reduceBy_1111; + <$SEL extends "11">(): (valueFn: (accumulator: U, value: T) => Reduced | U, values: List) => reduceBy_1111; <$SEL extends "1">(): (valueFn: (accumulator: U, value: T) => Reduced | U) => reduceBy_1110; <$SEL extends "01">(): (_valueFn: PH, values: List) => reduceBy_0111; (valueFn: (accumulator: U, value: T) => Reduced | U): reduceBy_1110; }; type reduceBy_1110 = { - (values: List): reduceBy_1111; + (values: List): reduceBy_1111; }; type reduceBy_0001 = { (valueFn: (accumulator: U, value: T) => Reduced | U, _initial: PH, keyFn: Morphism): reduceBy_1011; (_valueFn: PH, initial: U, keyFn: Morphism): reduceBy_0111; (_valueFn: PH, _initial: PH, keyFn: Morphism): reduceBy_0011; - (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, keyFn: Morphism): reduceBy_1111; + (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, keyFn: Morphism): reduceBy_1111; (_valueFn: PH, initial: U): reduceBy_0101; (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U): reduceBy_1101; - <$SEL extends "111">(): (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, keyFn: Morphism) => reduceBy_1111; + <$SEL extends "111">(): (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U, keyFn: Morphism) => reduceBy_1111; <$SEL extends "11">(): (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduceBy_1101; <$SEL extends "101">(): (valueFn: (accumulator: U, value: T) => Reduced | U, _initial: PH, keyFn: Morphism) => reduceBy_1011; <$SEL extends "1">(): (valueFn: (accumulator: U, value: T) => Reduced | U) => reduceBy_1001; @@ -170,36 +170,36 @@ type reduceBy_0001 = { }; type reduceBy_1001 = { (_initial: PH, keyFn: Morphism): reduceBy_1011; - (initial: U, keyFn: Morphism): reduceBy_1111; - <$SEL extends "11">(): (initial: U, keyFn: Morphism) => reduceBy_1111; + (initial: U, keyFn: Morphism): reduceBy_1111; + <$SEL extends "11">(): (initial: U, keyFn: Morphism) => reduceBy_1111; <$SEL extends "1">(): (initial: U) => reduceBy_1101; <$SEL extends "01">(): (_initial: PH, keyFn: Morphism) => reduceBy_1011; (initial: U): reduceBy_1101; }; type reduceBy_0101 = { (_valueFn: PH, keyFn: Morphism): reduceBy_0111; - (valueFn: (accumulator: U, value: T) => Reduced | U, keyFn: Morphism): reduceBy_1111; - <$SEL extends "11">(): (valueFn: (accumulator: U, value: T) => Reduced | U, keyFn: Morphism) => reduceBy_1111; + (valueFn: (accumulator: U, value: T) => Reduced | U, keyFn: Morphism): reduceBy_1111; + <$SEL extends "11">(): (valueFn: (accumulator: U, value: T) => Reduced | U, keyFn: Morphism) => reduceBy_1111; <$SEL extends "1">(): (valueFn: (accumulator: U, value: T) => Reduced | U) => reduceBy_1101; <$SEL extends "01">(): (_valueFn: PH, keyFn: Morphism) => reduceBy_0111; (valueFn: (accumulator: U, value: T) => Reduced | U): reduceBy_1101; }; type reduceBy_1101 = { - (keyFn: Morphism): reduceBy_1111; + (keyFn: Morphism): reduceBy_1111; }; type reduceBy_0011 = { (_valueFn: PH, initial: U): reduceBy_0111; - (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U): reduceBy_1111; - <$SEL extends "11">(): (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduceBy_1111; + (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U): reduceBy_1111; + <$SEL extends "11">(): (valueFn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduceBy_1111; <$SEL extends "1">(): (valueFn: (accumulator: U, value: T) => Reduced | U) => reduceBy_1011; <$SEL extends "01">(): (_valueFn: PH, initial: U) => reduceBy_0111; (valueFn: (accumulator: U, value: T) => Reduced | U): reduceBy_1011; }; type reduceBy_1011 = { - (initial: U): reduceBy_1111; + (initial: U): reduceBy_1111; }; type reduceBy_0111 = { - (valueFn: (accumulator: U, value: T) => Reduced | U): reduceBy_1111; + (valueFn: (accumulator: U, value: T) => Reduced | U): reduceBy_1111; }; -type reduceBy_1111 = Partial>; +type reduceBy_1111 = Partial>; export = reduceBy; diff --git a/ramda/dist/src/reduceRight.d.ts b/ramda/dist/src/reduceRight.d.ts index 662222d..68734fb 100644 --- a/ramda/dist/src/reduceRight.d.ts +++ b/ramda/dist/src/reduceRight.d.ts @@ -47,10 +47,10 @@ type reduceRight_000 = { (fn: (value: T, accumulator: U) => Reduced | U, _initial: PH, values: List): reduceRight_101; (_fn: PH, initial: U, values: List): reduceRight_011; (_fn: PH, _initial: PH, values: List): reduceRight_001; - (fn: (value: T, accumulator: U) => Reduced | U, initial: U, values: List): reduceRight_111; + (fn: (value: T, accumulator: U) => Reduced | U, initial: U, values: List): reduceRight_111; (_fn: PH, initial: U): reduceRight_010; (fn: (value: T, accumulator: U) => Reduced | U, initial: U): reduceRight_110; - <$SEL extends "111">(): (fn: (value: T, accumulator: U) => Reduced | U, initial: U, values: List) => reduceRight_111; + <$SEL extends "111">(): (fn: (value: T, accumulator: U) => Reduced | U, initial: U, values: List) => reduceRight_111; <$SEL extends "11">(): (fn: (value: T, accumulator: U) => Reduced | U, initial: U) => reduceRight_110; <$SEL extends "101">(): (fn: (value: T, accumulator: U) => Reduced | U, _initial: PH, values: List) => reduceRight_101; <$SEL extends "1">(): (fn: (value: T, accumulator: U) => Reduced | U) => reduceRight_100; @@ -61,36 +61,36 @@ type reduceRight_000 = { }; type reduceRight_100 = { (_initial: PH, values: List): reduceRight_101; - (initial: U, values: List): reduceRight_111; - <$SEL extends "11">(): (initial: U, values: List) => reduceRight_111; + (initial: U, values: List): reduceRight_111; + <$SEL extends "11">(): (initial: U, values: List) => reduceRight_111; <$SEL extends "1">(): (initial: U) => reduceRight_110; <$SEL extends "01">(): (_initial: PH, values: List) => reduceRight_101; (initial: U): reduceRight_110; }; type reduceRight_010 = { (_fn: PH, values: List): reduceRight_011; - (fn: (value: T, accumulator: U) => Reduced | U, values: List): reduceRight_111; - <$SEL extends "11">(): (fn: (value: T, accumulator: U) => Reduced | U, values: List) => reduceRight_111; + (fn: (value: T, accumulator: U) => Reduced | U, values: List): reduceRight_111; + <$SEL extends "11">(): (fn: (value: T, accumulator: U) => Reduced | U, values: List) => reduceRight_111; <$SEL extends "1">(): (fn: (value: T, accumulator: U) => Reduced | U) => reduceRight_110; <$SEL extends "01">(): (_fn: PH, values: List) => reduceRight_011; (fn: (value: T, accumulator: U) => Reduced | U): reduceRight_110; }; type reduceRight_110 = { - (values: List): reduceRight_111; + (values: List): reduceRight_111; }; type reduceRight_001 = { (_fn: PH, initial: U): reduceRight_011; - (fn: (value: T, accumulator: U) => Reduced | U, initial: U): reduceRight_111; - <$SEL extends "11">(): (fn: (value: T, accumulator: U) => Reduced | U, initial: U) => reduceRight_111; + (fn: (value: T, accumulator: U) => Reduced | U, initial: U): reduceRight_111; + <$SEL extends "11">(): (fn: (value: T, accumulator: U) => Reduced | U, initial: U) => reduceRight_111; <$SEL extends "1">(): (fn: (value: T, accumulator: U) => Reduced | U) => reduceRight_101; <$SEL extends "01">(): (_fn: PH, initial: U) => reduceRight_011; (fn: (value: T, accumulator: U) => Reduced | U): reduceRight_101; }; type reduceRight_101 = { - (initial: U): reduceRight_111; + (initial: U): reduceRight_111; }; type reduceRight_011 = { - (fn: (value: T, accumulator: U) => Reduced | U): reduceRight_111; + (fn: (value: T, accumulator: U) => Reduced | U): reduceRight_111; }; -type reduceRight_111 = U; +type reduceRight_111 = U; export = reduceRight; diff --git a/ramda/dist/src/reduceWhile.d.ts b/ramda/dist/src/reduceWhile.d.ts index b4579f6..1710b1d 100644 --- a/ramda/dist/src/reduceWhile.d.ts +++ b/ramda/dist/src/reduceWhile.d.ts @@ -38,14 +38,14 @@ type reduceWhile_0000 = { (_pred: PH, fn: (accumulator: U, value: T) => Reduced | U, _initial: PH, values: List): reduceWhile_0101; (_pred: PH, _fn: PH, initial: U, values: List): reduceWhile_0011; (_pred: PH, _fn: PH, _initial: PH, values: List): reduceWhile_0001; - (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List): reduceWhile_1111; + (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List): reduceWhile_1111; (pred: (accumulator: U, value: T) => boolean, _fn: PH, initial: U): reduceWhile_1010; (_pred: PH, fn: (accumulator: U, value: T) => Reduced | U, initial: U): reduceWhile_0110; (_pred: PH, _fn: PH, initial: U): reduceWhile_0010; (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, initial: U): reduceWhile_1110; (_pred: PH, fn: (accumulator: U, value: T) => Reduced | U): reduceWhile_0100; (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U): reduceWhile_1100; - <$SEL extends "1111">(): (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List) => reduceWhile_1111; + <$SEL extends "1111">(): (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List) => reduceWhile_1111; <$SEL extends "111">(): (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduceWhile_1110; <$SEL extends "1101">(): (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, _initial: PH, values: List) => reduceWhile_1101; <$SEL extends "11">(): (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U) => reduceWhile_1100; @@ -66,10 +66,10 @@ type reduceWhile_1000 = { (fn: (accumulator: U, value: T) => Reduced | U, _initial: PH, values: List): reduceWhile_1101; (_fn: PH, initial: U, values: List): reduceWhile_1011; (_fn: PH, _initial: PH, values: List): reduceWhile_1001; - (fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List): reduceWhile_1111; + (fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List): reduceWhile_1111; (_fn: PH, initial: U): reduceWhile_1010; (fn: (accumulator: U, value: T) => Reduced | U, initial: U): reduceWhile_1110; - <$SEL extends "111">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List) => reduceWhile_1111; + <$SEL extends "111">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List) => reduceWhile_1111; <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduceWhile_1110; <$SEL extends "101">(): (fn: (accumulator: U, value: T) => Reduced | U, _initial: PH, values: List) => reduceWhile_1101; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => Reduced | U) => reduceWhile_1100; @@ -82,10 +82,10 @@ type reduceWhile_0100 = { (pred: (accumulator: U, value: T) => boolean, _initial: PH, values: List): reduceWhile_1101; (_pred: PH, initial: U, values: List): reduceWhile_0111; (_pred: PH, _initial: PH, values: List): reduceWhile_0101; - (pred: (accumulator: U, value: T) => boolean, initial: U, values: List): reduceWhile_1111; + (pred: (accumulator: U, value: T) => boolean, initial: U, values: List): reduceWhile_1111; (_pred: PH, initial: U): reduceWhile_0110; (pred: (accumulator: U, value: T) => boolean, initial: U): reduceWhile_1110; - <$SEL extends "111">(): (pred: (accumulator: U, value: T) => boolean, initial: U, values: List) => reduceWhile_1111; + <$SEL extends "111">(): (pred: (accumulator: U, value: T) => boolean, initial: U, values: List) => reduceWhile_1111; <$SEL extends "11">(): (pred: (accumulator: U, value: T) => boolean, initial: U) => reduceWhile_1110; <$SEL extends "101">(): (pred: (accumulator: U, value: T) => boolean, _initial: PH, values: List) => reduceWhile_1101; <$SEL extends "1">(): (pred: (accumulator: U, value: T) => boolean) => reduceWhile_1100; @@ -96,8 +96,8 @@ type reduceWhile_0100 = { }; type reduceWhile_1100 = { (_initial: PH, values: List): reduceWhile_1101; - (initial: U, values: List): reduceWhile_1111; - <$SEL extends "11">(): (initial: U, values: List) => reduceWhile_1111; + (initial: U, values: List): reduceWhile_1111; + <$SEL extends "11">(): (initial: U, values: List) => reduceWhile_1111; <$SEL extends "1">(): (initial: U) => reduceWhile_1110; <$SEL extends "01">(): (_initial: PH, values: List) => reduceWhile_1101; (initial: U): reduceWhile_1110; @@ -106,10 +106,10 @@ type reduceWhile_0010 = { (pred: (accumulator: U, value: T) => boolean, _fn: PH, values: List): reduceWhile_1011; (_pred: PH, fn: (accumulator: U, value: T) => Reduced | U, values: List): reduceWhile_0111; (_pred: PH, _fn: PH, values: List): reduceWhile_0011; - (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, values: List): reduceWhile_1111; + (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, values: List): reduceWhile_1111; (_pred: PH, fn: (accumulator: U, value: T) => Reduced | U): reduceWhile_0110; (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U): reduceWhile_1110; - <$SEL extends "111">(): (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, values: List) => reduceWhile_1111; + <$SEL extends "111">(): (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, values: List) => reduceWhile_1111; <$SEL extends "11">(): (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U) => reduceWhile_1110; <$SEL extends "101">(): (pred: (accumulator: U, value: T) => boolean, _fn: PH, values: List) => reduceWhile_1011; <$SEL extends "1">(): (pred: (accumulator: U, value: T) => boolean) => reduceWhile_1010; @@ -120,31 +120,31 @@ type reduceWhile_0010 = { }; type reduceWhile_1010 = { (_fn: PH, values: List): reduceWhile_1011; - (fn: (accumulator: U, value: T) => Reduced | U, values: List): reduceWhile_1111; - <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, values: List) => reduceWhile_1111; + (fn: (accumulator: U, value: T) => Reduced | U, values: List): reduceWhile_1111; + <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, values: List) => reduceWhile_1111; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => Reduced | U) => reduceWhile_1110; <$SEL extends "01">(): (_fn: PH, values: List) => reduceWhile_1011; (fn: (accumulator: U, value: T) => Reduced | U): reduceWhile_1110; }; type reduceWhile_0110 = { (_pred: PH, values: List): reduceWhile_0111; - (pred: (accumulator: U, value: T) => boolean, values: List): reduceWhile_1111; - <$SEL extends "11">(): (pred: (accumulator: U, value: T) => boolean, values: List) => reduceWhile_1111; + (pred: (accumulator: U, value: T) => boolean, values: List): reduceWhile_1111; + <$SEL extends "11">(): (pred: (accumulator: U, value: T) => boolean, values: List) => reduceWhile_1111; <$SEL extends "1">(): (pred: (accumulator: U, value: T) => boolean) => reduceWhile_1110; <$SEL extends "01">(): (_pred: PH, values: List) => reduceWhile_0111; (pred: (accumulator: U, value: T) => boolean): reduceWhile_1110; }; type reduceWhile_1110 = { - (values: List): reduceWhile_1111; + (values: List): reduceWhile_1111; }; type reduceWhile_0001 = { (pred: (accumulator: U, value: T) => boolean, _fn: PH, initial: U): reduceWhile_1011; (_pred: PH, fn: (accumulator: U, value: T) => Reduced | U, initial: U): reduceWhile_0111; (_pred: PH, _fn: PH, initial: U): reduceWhile_0011; - (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, initial: U): reduceWhile_1111; + (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, initial: U): reduceWhile_1111; (_pred: PH, fn: (accumulator: U, value: T) => Reduced | U): reduceWhile_0101; (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U): reduceWhile_1101; - <$SEL extends "111">(): (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduceWhile_1111; + <$SEL extends "111">(): (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduceWhile_1111; <$SEL extends "11">(): (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U) => reduceWhile_1101; <$SEL extends "101">(): (pred: (accumulator: U, value: T) => boolean, _fn: PH, initial: U) => reduceWhile_1011; <$SEL extends "1">(): (pred: (accumulator: U, value: T) => boolean) => reduceWhile_1001; @@ -155,36 +155,36 @@ type reduceWhile_0001 = { }; type reduceWhile_1001 = { (_fn: PH, initial: U): reduceWhile_1011; - (fn: (accumulator: U, value: T) => Reduced | U, initial: U): reduceWhile_1111; - <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduceWhile_1111; + (fn: (accumulator: U, value: T) => Reduced | U, initial: U): reduceWhile_1111; + <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U) => reduceWhile_1111; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => Reduced | U) => reduceWhile_1101; <$SEL extends "01">(): (_fn: PH, initial: U) => reduceWhile_1011; (fn: (accumulator: U, value: T) => Reduced | U): reduceWhile_1101; }; type reduceWhile_0101 = { (_pred: PH, initial: U): reduceWhile_0111; - (pred: (accumulator: U, value: T) => boolean, initial: U): reduceWhile_1111; - <$SEL extends "11">(): (pred: (accumulator: U, value: T) => boolean, initial: U) => reduceWhile_1111; + (pred: (accumulator: U, value: T) => boolean, initial: U): reduceWhile_1111; + <$SEL extends "11">(): (pred: (accumulator: U, value: T) => boolean, initial: U) => reduceWhile_1111; <$SEL extends "1">(): (pred: (accumulator: U, value: T) => boolean) => reduceWhile_1101; <$SEL extends "01">(): (_pred: PH, initial: U) => reduceWhile_0111; (pred: (accumulator: U, value: T) => boolean): reduceWhile_1101; }; type reduceWhile_1101 = { - (initial: U): reduceWhile_1111; + (initial: U): reduceWhile_1111; }; type reduceWhile_0011 = { (_pred: PH, fn: (accumulator: U, value: T) => Reduced | U): reduceWhile_0111; - (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U): reduceWhile_1111; - <$SEL extends "11">(): (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U) => reduceWhile_1111; + (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U): reduceWhile_1111; + <$SEL extends "11">(): (pred: (accumulator: U, value: T) => boolean, fn: (accumulator: U, value: T) => Reduced | U) => reduceWhile_1111; <$SEL extends "1">(): (pred: (accumulator: U, value: T) => boolean) => reduceWhile_1011; <$SEL extends "01">(): (_pred: PH, fn: (accumulator: U, value: T) => Reduced | U) => reduceWhile_0111; (pred: (accumulator: U, value: T) => boolean): reduceWhile_1011; }; type reduceWhile_1011 = { - (fn: (accumulator: U, value: T) => Reduced | U): reduceWhile_1111; + (fn: (accumulator: U, value: T) => Reduced | U): reduceWhile_1111; }; type reduceWhile_0111 = { - (pred: (accumulator: U, value: T) => boolean): reduceWhile_1111; + (pred: (accumulator: U, value: T) => boolean): reduceWhile_1111; }; -type reduceWhile_1111 = U; +type reduceWhile_1111 = U; export = reduceWhile; diff --git a/ramda/dist/src/scan.d.ts b/ramda/dist/src/scan.d.ts index a42810a..8ffcf57 100644 --- a/ramda/dist/src/scan.d.ts +++ b/ramda/dist/src/scan.d.ts @@ -26,10 +26,10 @@ type scan_000 = { (fn: (accumulator: U, value: T) => Reduced | U, _initial: PH, values: List): scan_101; (_fn: PH, initial: U, values: List): scan_011; (_fn: PH, _initial: PH, values: List): scan_001; - (fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List): scan_111; + (fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List): scan_111; (_fn: PH, initial: U): scan_010; (fn: (accumulator: U, value: T) => Reduced | U, initial: U): scan_110; - <$SEL extends "111">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List) => scan_111; + <$SEL extends "111">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U, values: List) => scan_111; <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U) => scan_110; <$SEL extends "101">(): (fn: (accumulator: U, value: T) => Reduced | U, _initial: PH, values: List) => scan_101; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => Reduced | U) => scan_100; @@ -40,36 +40,36 @@ type scan_000 = { }; type scan_100 = { (_initial: PH, values: List): scan_101; - (initial: U, values: List): scan_111; - <$SEL extends "11">(): (initial: U, values: List) => scan_111; + (initial: U, values: List): scan_111; + <$SEL extends "11">(): (initial: U, values: List) => scan_111; <$SEL extends "1">(): (initial: U) => scan_110; <$SEL extends "01">(): (_initial: PH, values: List) => scan_101; (initial: U): scan_110; }; type scan_010 = { (_fn: PH, values: List): scan_011; - (fn: (accumulator: U, value: T) => Reduced | U, values: List): scan_111; - <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, values: List) => scan_111; + (fn: (accumulator: U, value: T) => Reduced | U, values: List): scan_111; + <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, values: List) => scan_111; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => Reduced | U) => scan_110; <$SEL extends "01">(): (_fn: PH, values: List) => scan_011; (fn: (accumulator: U, value: T) => Reduced | U): scan_110; }; type scan_110 = { - (values: List): scan_111; + (values: List): scan_111; }; type scan_001 = { (_fn: PH, initial: U): scan_011; - (fn: (accumulator: U, value: T) => Reduced | U, initial: U): scan_111; - <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U) => scan_111; + (fn: (accumulator: U, value: T) => Reduced | U, initial: U): scan_111; + <$SEL extends "11">(): (fn: (accumulator: U, value: T) => Reduced | U, initial: U) => scan_111; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => Reduced | U) => scan_101; <$SEL extends "01">(): (_fn: PH, initial: U) => scan_011; (fn: (accumulator: U, value: T) => Reduced | U): scan_101; }; type scan_101 = { - (initial: U): scan_111; + (initial: U): scan_111; }; type scan_011 = { - (fn: (accumulator: U, value: T) => Reduced | U): scan_111; + (fn: (accumulator: U, value: T) => Reduced | U): scan_111; }; -type scan_111 = U[]; +type scan_111 = U[]; export = scan; diff --git a/ramda/dist/src/set.d.ts b/ramda/dist/src/set.d.ts index 6db118a..04c0b08 100644 --- a/ramda/dist/src/set.d.ts +++ b/ramda/dist/src/set.d.ts @@ -27,10 +27,10 @@ type set_000 = { (lens: Lens, _value: PH, target: U): set_101; (_lens: PH, value: T, target: U): set_011; (_lens: PH, _value: PH, target: U): set_001; - (lens: Lens, value: T, target: U): set_111; + (lens: Lens, value: T, target: U): set_111; (_lens: PH, value: T): set_010; (lens: Lens, value: T): set_110; - <$SEL extends "111">(): (lens: Lens, value: T, target: U) => set_111; + <$SEL extends "111">(): (lens: Lens, value: T, target: U) => set_111; <$SEL extends "11">(): (lens: Lens, value: T) => set_110; <$SEL extends "101">(): (lens: Lens, _value: PH, target: U) => set_101; <$SEL extends "1">(): (lens: Lens) => set_100; @@ -41,36 +41,36 @@ type set_000 = { }; type set_100 = { (_value: PH, target: U): set_101; - (value: T, target: U): set_111; - <$SEL extends "11">(): (value: T, target: U) => set_111; + (value: T, target: U): set_111; + <$SEL extends "11">(): (value: T, target: U) => set_111; <$SEL extends "1">(): (value: T) => set_110; <$SEL extends "01">(): (_value: PH, target: U) => set_101; (value: T): set_110; }; type set_010 = { (_lens: PH, target: U): set_011; - (lens: Lens, target: U): set_111; - <$SEL extends "11">(): (lens: Lens, target: U) => set_111; + (lens: Lens, target: U): set_111; + <$SEL extends "11">(): (lens: Lens, target: U) => set_111; <$SEL extends "1">(): (lens: Lens) => set_110; <$SEL extends "01">(): (_lens: PH, target: U) => set_011; (lens: Lens): set_110; }; type set_110 = { - (target: U): set_111; + (target: U): set_111; }; type set_001 = { (_lens: PH, value: T): set_011; - (lens: Lens, value: T): set_111; - <$SEL extends "11">(): (lens: Lens, value: T) => set_111; + (lens: Lens, value: T): set_111; + <$SEL extends "11">(): (lens: Lens, value: T) => set_111; <$SEL extends "1">(): (lens: Lens) => set_101; <$SEL extends "01">(): (_lens: PH, value: T) => set_011; (lens: Lens): set_101; }; type set_101 = { - (value: T): set_111; + (value: T): set_111; }; type set_011 = { - (lens: Lens): set_111; + (lens: Lens): set_111; }; -type set_111 = U; +type set_111 = U; export = set; diff --git a/ramda/dist/src/startsWith.d.ts b/ramda/dist/src/startsWith.d.ts index 71eada1..d98b908 100644 --- a/ramda/dist/src/startsWith.d.ts +++ b/ramda/dist/src/startsWith.d.ts @@ -22,17 +22,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const startsWith: startsWith_00; type startsWith_00 = { >(_prefix: PH, list: T): startsWith_01; - >(prefix: T, list: T): startsWith_11; - <$SEL extends "11">(): >(prefix: T, list: T) => startsWith_11; + >(prefix: T, list: T): startsWith_11; + <$SEL extends "11">(): >(prefix: T, list: T) => startsWith_11; <$SEL extends "1">(): >(prefix: T) => startsWith_10; <$SEL extends "01">(): >(_prefix: PH, list: T) => startsWith_01; >(prefix: T): startsWith_10; }; type startsWith_10> = { - (list: T): startsWith_11; + (list: T): startsWith_11; }; type startsWith_01> = { - (prefix: T): startsWith_11; + (prefix: T): startsWith_11; }; -type startsWith_11> = boolean; +type startsWith_11 = boolean; export = startsWith; diff --git a/ramda/dist/src/transduce.d.ts b/ramda/dist/src/transduce.d.ts index 49f1a2e..022303b 100644 --- a/ramda/dist/src/transduce.d.ts +++ b/ramda/dist/src/transduce.d.ts @@ -56,14 +56,14 @@ type transduce_0000 = { (_transducer: PH, fn: (accumulator: U, value: T) => U | Reduced, _initial: PH, values: T[]): transduce_0101; (_transducer: PH, _fn: PH, initial: U, values: T[]): transduce_0011; (_transducer: PH, _fn: PH, _initial: PH, values: T[]): transduce_0001; - (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, initial: U, values: T[]): transduce_1111; + (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, initial: U, values: T[]): transduce_1111; (transducer: Morphism | Morphism, Transformer>, _fn: PH, initial: U): transduce_1010; (_transducer: PH, fn: (accumulator: U, value: T) => U | Reduced, initial: U): transduce_0110; (_transducer: PH, _fn: PH, initial: U): transduce_0010; (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, initial: U): transduce_1110; (_transducer: PH, fn: (accumulator: U, value: T) => U | Reduced): transduce_0100; (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced): transduce_1100; - <$SEL extends "1111">(): (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, initial: U, values: T[]) => transduce_1111; + <$SEL extends "1111">(): (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, initial: U, values: T[]) => transduce_1111; <$SEL extends "111">(): (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, initial: U) => transduce_1110; <$SEL extends "1101">(): (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, _initial: PH, values: T[]) => transduce_1101; <$SEL extends "11">(): (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced) => transduce_1100; @@ -84,10 +84,10 @@ type transduce_1000 = { (fn: (accumulator: U, value: T) => U | Reduced, _initial: PH, values: T[]): transduce_1101; (_fn: PH, initial: U, values: T[]): transduce_1011; (_fn: PH, _initial: PH, values: T[]): transduce_1001; - (fn: (accumulator: U, value: T) => U | Reduced, initial: U, values: T[]): transduce_1111; + (fn: (accumulator: U, value: T) => U | Reduced, initial: U, values: T[]): transduce_1111; (_fn: PH, initial: U): transduce_1010; (fn: (accumulator: U, value: T) => U | Reduced, initial: U): transduce_1110; - <$SEL extends "111">(): (fn: (accumulator: U, value: T) => U | Reduced, initial: U, values: T[]) => transduce_1111; + <$SEL extends "111">(): (fn: (accumulator: U, value: T) => U | Reduced, initial: U, values: T[]) => transduce_1111; <$SEL extends "11">(): (fn: (accumulator: U, value: T) => U | Reduced, initial: U) => transduce_1110; <$SEL extends "101">(): (fn: (accumulator: U, value: T) => U | Reduced, _initial: PH, values: T[]) => transduce_1101; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => U | Reduced) => transduce_1100; @@ -100,10 +100,10 @@ type transduce_0100 = { (transducer: Morphism | Morphism, Transformer>, _initial: PH, values: T[]): transduce_1101; (_transducer: PH, initial: U, values: T[]): transduce_0111; (_transducer: PH, _initial: PH, values: T[]): transduce_0101; - (transducer: Morphism | Morphism, Transformer>, initial: U, values: T[]): transduce_1111; + (transducer: Morphism | Morphism, Transformer>, initial: U, values: T[]): transduce_1111; (_transducer: PH, initial: U): transduce_0110; (transducer: Morphism | Morphism, Transformer>, initial: U): transduce_1110; - <$SEL extends "111">(): (transducer: Morphism | Morphism, Transformer>, initial: U, values: T[]) => transduce_1111; + <$SEL extends "111">(): (transducer: Morphism | Morphism, Transformer>, initial: U, values: T[]) => transduce_1111; <$SEL extends "11">(): (transducer: Morphism | Morphism, Transformer>, initial: U) => transduce_1110; <$SEL extends "101">(): (transducer: Morphism | Morphism, Transformer>, _initial: PH, values: T[]) => transduce_1101; <$SEL extends "1">(): (transducer: Morphism | Morphism, Transformer>) => transduce_1100; @@ -114,8 +114,8 @@ type transduce_0100 = { }; type transduce_1100 = { (_initial: PH, values: T[]): transduce_1101; - (initial: U, values: T[]): transduce_1111; - <$SEL extends "11">(): (initial: U, values: T[]) => transduce_1111; + (initial: U, values: T[]): transduce_1111; + <$SEL extends "11">(): (initial: U, values: T[]) => transduce_1111; <$SEL extends "1">(): (initial: U) => transduce_1110; <$SEL extends "01">(): (_initial: PH, values: T[]) => transduce_1101; (initial: U): transduce_1110; @@ -124,10 +124,10 @@ type transduce_0010 = { (transducer: Morphism | Morphism, Transformer>, _fn: PH, values: T[]): transduce_1011; (_transducer: PH, fn: (accumulator: U, value: T) => U | Reduced, values: T[]): transduce_0111; (_transducer: PH, _fn: PH, values: T[]): transduce_0011; - (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, values: T[]): transduce_1111; + (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, values: T[]): transduce_1111; (_transducer: PH, fn: (accumulator: U, value: T) => U | Reduced): transduce_0110; (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced): transduce_1110; - <$SEL extends "111">(): (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, values: T[]) => transduce_1111; + <$SEL extends "111">(): (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, values: T[]) => transduce_1111; <$SEL extends "11">(): (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced) => transduce_1110; <$SEL extends "101">(): (transducer: Morphism | Morphism, Transformer>, _fn: PH, values: T[]) => transduce_1011; <$SEL extends "1">(): (transducer: Morphism | Morphism, Transformer>) => transduce_1010; @@ -138,31 +138,31 @@ type transduce_0010 = { }; type transduce_1010 = { (_fn: PH, values: T[]): transduce_1011; - (fn: (accumulator: U, value: T) => U | Reduced, values: T[]): transduce_1111; - <$SEL extends "11">(): (fn: (accumulator: U, value: T) => U | Reduced, values: T[]) => transduce_1111; + (fn: (accumulator: U, value: T) => U | Reduced, values: T[]): transduce_1111; + <$SEL extends "11">(): (fn: (accumulator: U, value: T) => U | Reduced, values: T[]) => transduce_1111; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => U | Reduced) => transduce_1110; <$SEL extends "01">(): (_fn: PH, values: T[]) => transduce_1011; (fn: (accumulator: U, value: T) => U | Reduced): transduce_1110; }; type transduce_0110 = { (_transducer: PH, values: T[]): transduce_0111; - (transducer: Morphism | Morphism, Transformer>, values: T[]): transduce_1111; - <$SEL extends "11">(): (transducer: Morphism | Morphism, Transformer>, values: T[]) => transduce_1111; + (transducer: Morphism | Morphism, Transformer>, values: T[]): transduce_1111; + <$SEL extends "11">(): (transducer: Morphism | Morphism, Transformer>, values: T[]) => transduce_1111; <$SEL extends "1">(): (transducer: Morphism | Morphism, Transformer>) => transduce_1110; <$SEL extends "01">(): (_transducer: PH, values: T[]) => transduce_0111; (transducer: Morphism | Morphism, Transformer>): transduce_1110; }; type transduce_1110 = { - (values: T[]): transduce_1111; + (values: T[]): transduce_1111; }; type transduce_0001 = { (transducer: Morphism | Morphism, Transformer>, _fn: PH, initial: U): transduce_1011; (_transducer: PH, fn: (accumulator: U, value: T) => U | Reduced, initial: U): transduce_0111; (_transducer: PH, _fn: PH, initial: U): transduce_0011; - (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, initial: U): transduce_1111; + (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, initial: U): transduce_1111; (_transducer: PH, fn: (accumulator: U, value: T) => U | Reduced): transduce_0101; (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced): transduce_1101; - <$SEL extends "111">(): (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, initial: U) => transduce_1111; + <$SEL extends "111">(): (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced, initial: U) => transduce_1111; <$SEL extends "11">(): (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced) => transduce_1101; <$SEL extends "101">(): (transducer: Morphism | Morphism, Transformer>, _fn: PH, initial: U) => transduce_1011; <$SEL extends "1">(): (transducer: Morphism | Morphism, Transformer>) => transduce_1001; @@ -173,36 +173,36 @@ type transduce_0001 = { }; type transduce_1001 = { (_fn: PH, initial: U): transduce_1011; - (fn: (accumulator: U, value: T) => U | Reduced, initial: U): transduce_1111; - <$SEL extends "11">(): (fn: (accumulator: U, value: T) => U | Reduced, initial: U) => transduce_1111; + (fn: (accumulator: U, value: T) => U | Reduced, initial: U): transduce_1111; + <$SEL extends "11">(): (fn: (accumulator: U, value: T) => U | Reduced, initial: U) => transduce_1111; <$SEL extends "1">(): (fn: (accumulator: U, value: T) => U | Reduced) => transduce_1101; <$SEL extends "01">(): (_fn: PH, initial: U) => transduce_1011; (fn: (accumulator: U, value: T) => U | Reduced): transduce_1101; }; type transduce_0101 = { (_transducer: PH, initial: U): transduce_0111; - (transducer: Morphism | Morphism, Transformer>, initial: U): transduce_1111; - <$SEL extends "11">(): (transducer: Morphism | Morphism, Transformer>, initial: U) => transduce_1111; + (transducer: Morphism | Morphism, Transformer>, initial: U): transduce_1111; + <$SEL extends "11">(): (transducer: Morphism | Morphism, Transformer>, initial: U) => transduce_1111; <$SEL extends "1">(): (transducer: Morphism | Morphism, Transformer>) => transduce_1101; <$SEL extends "01">(): (_transducer: PH, initial: U) => transduce_0111; (transducer: Morphism | Morphism, Transformer>): transduce_1101; }; type transduce_1101 = { - (initial: U): transduce_1111; + (initial: U): transduce_1111; }; type transduce_0011 = { (_transducer: PH, fn: (accumulator: U, value: T) => U | Reduced): transduce_0111; - (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced): transduce_1111; - <$SEL extends "11">(): (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced) => transduce_1111; + (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced): transduce_1111; + <$SEL extends "11">(): (transducer: Morphism | Morphism, Transformer>, fn: (accumulator: U, value: T) => U | Reduced) => transduce_1111; <$SEL extends "1">(): (transducer: Morphism | Morphism, Transformer>) => transduce_1011; <$SEL extends "01">(): (_transducer: PH, fn: (accumulator: U, value: T) => U | Reduced) => transduce_0111; (transducer: Morphism | Morphism, Transformer>): transduce_1011; }; type transduce_1011 = { - (fn: (accumulator: U, value: T) => U | Reduced): transduce_1111; + (fn: (accumulator: U, value: T) => U | Reduced): transduce_1111; }; type transduce_0111 = { - (transducer: Morphism | Morphism, Transformer>): transduce_1111; + (transducer: Morphism | Morphism, Transformer>): transduce_1111; }; -type transduce_1111 = U; +type transduce_1111 = U; export = transduce; diff --git a/ramda/dist/src/traverse.d.ts b/ramda/dist/src/traverse.d.ts index fe30bde..f579bce 100644 --- a/ramda/dist/src/traverse.d.ts +++ b/ramda/dist/src/traverse.d.ts @@ -34,15 +34,15 @@ type traverse_000 = { (_of: PH, _fn: PH, traversable: List): traverse_list_001; (_of: PH, fn: Morphism>, traversable: Traversable): traverse_traversable_011; (_of: PH, _fn: PH, traversable: Traversable): traverse_traversable_001; - (of: Morphism>, fn: Morphism>, traversable: List): traverse_list_111; - (of: Morphism>, fn: Morphism>, traversable: Traversable): traverse_traversable_111; + (of: Morphism>, fn: Morphism>, traversable: List): traverse_list_111; + (of: Morphism>, fn: Morphism>, traversable: Traversable): traverse_traversable_111; (_of: PH, fn: Morphism>): traverse_010; (of: Morphism>, fn: Morphism>): traverse_110; - <$SEL extends "111", $KIND extends "list">(): (of: Morphism>, fn: Morphism>, traversable: List) => traverse_list_111; + <$SEL extends "111", $KIND extends "list">(): (of: Morphism>, fn: Morphism>, traversable: List) => traverse_list_111; <$SEL extends "101", $KIND extends "list">(): (of: Morphism>, _fn: PH, traversable: List) => traverse_list_101; <$SEL extends "011", $KIND extends "list">(): (_of: PH, fn: Morphism>, traversable: List) => traverse_list_011; <$SEL extends "001", $KIND extends "list">(): (_of: PH, _fn: PH, traversable: List) => traverse_list_001; - <$SEL extends "111", $KIND extends "traversable">(): (of: Morphism>, fn: Morphism>, traversable: Traversable) => traverse_traversable_111; + <$SEL extends "111", $KIND extends "traversable">(): (of: Morphism>, fn: Morphism>, traversable: Traversable) => traverse_traversable_111; <$SEL extends "101", $KIND extends "traversable">(): (of: Morphism>, _fn: PH, traversable: Traversable) => traverse_traversable_101; <$SEL extends "011", $KIND extends "traversable">(): (_of: PH, fn: Morphism>, traversable: Traversable) => traverse_traversable_011; <$SEL extends "001", $KIND extends "traversable">(): (_of: PH, _fn: PH, traversable: Traversable) => traverse_traversable_001; @@ -54,11 +54,11 @@ type traverse_000 = { type traverse_100 = { (_fn: PH, traversable: List): traverse_list_101; (_fn: PH, traversable: Traversable): traverse_traversable_101; - (fn: Morphism>, traversable: List): traverse_list_111; - (fn: Morphism>, traversable: Traversable): traverse_traversable_111; - <$SEL extends "11", $KIND extends "list">(): (fn: Morphism>, traversable: List) => traverse_list_111; + (fn: Morphism>, traversable: List): traverse_list_111; + (fn: Morphism>, traversable: Traversable): traverse_traversable_111; + <$SEL extends "11", $KIND extends "list">(): (fn: Morphism>, traversable: List) => traverse_list_111; <$SEL extends "01", $KIND extends "list">(): (_fn: PH, traversable: List) => traverse_list_101; - <$SEL extends "11", $KIND extends "traversable">(): (fn: Morphism>, traversable: Traversable) => traverse_traversable_111; + <$SEL extends "11", $KIND extends "traversable">(): (fn: Morphism>, traversable: Traversable) => traverse_traversable_111; <$SEL extends "01", $KIND extends "traversable">(): (_fn: PH, traversable: Traversable) => traverse_traversable_101; <$SEL extends "1">(): (fn: Morphism>) => traverse_110; (fn: Morphism>): traverse_110; @@ -66,49 +66,49 @@ type traverse_100 = { type traverse_010 = { (_of: PH, traversable: List): traverse_list_011; (_of: PH, traversable: Traversable): traverse_traversable_011; - (of: Morphism>, traversable: List): traverse_list_111; - (of: Morphism>, traversable: Traversable): traverse_traversable_111; - <$SEL extends "11", $KIND extends "list">(): (of: Morphism>, traversable: List) => traverse_list_111; + (of: Morphism>, traversable: List): traverse_list_111; + (of: Morphism>, traversable: Traversable): traverse_traversable_111; + <$SEL extends "11", $KIND extends "list">(): (of: Morphism>, traversable: List) => traverse_list_111; <$SEL extends "01", $KIND extends "list">(): (_of: PH, traversable: List) => traverse_list_011; - <$SEL extends "11", $KIND extends "traversable">(): (of: Morphism>, traversable: Traversable) => traverse_traversable_111; + <$SEL extends "11", $KIND extends "traversable">(): (of: Morphism>, traversable: Traversable) => traverse_traversable_111; <$SEL extends "01", $KIND extends "traversable">(): (_of: PH, traversable: Traversable) => traverse_traversable_011; <$SEL extends "1">(): (of: Morphism>) => traverse_110; (of: Morphism>): traverse_110; }; type traverse_110 = { - (traversable: List): traverse_list_111; - <$SEL extends "1", $KIND extends "list">(): (traversable: List) => traverse_list_111; - <$SEL extends "1", $KIND extends "traversable">(): (traversable: Traversable) => traverse_traversable_111; - (traversable: Traversable): traverse_traversable_111; + (traversable: List): traverse_list_111; + <$SEL extends "1", $KIND extends "list">(): (traversable: List) => traverse_list_111; + <$SEL extends "1", $KIND extends "traversable">(): (traversable: Traversable) => traverse_traversable_111; + (traversable: Traversable): traverse_traversable_111; }; type traverse_list_001 = { (_of: PH, fn: Morphism>): traverse_list_011; - (of: Morphism>, fn: Morphism>): traverse_list_111; - <$SEL extends "11">(): (of: Morphism>, fn: Morphism>) => traverse_list_111; + (of: Morphism>, fn: Morphism>): traverse_list_111; + <$SEL extends "11">(): (of: Morphism>, fn: Morphism>) => traverse_list_111; <$SEL extends "1">(): (of: Morphism>) => traverse_list_101; <$SEL extends "01">(): (_of: PH, fn: Morphism>) => traverse_list_011; (of: Morphism>): traverse_list_101; }; type traverse_traversable_001 = { (_of: PH, fn: Morphism>): traverse_traversable_011; - (of: Morphism>, fn: Morphism>): traverse_traversable_111; - <$SEL extends "11">(): (of: Morphism>, fn: Morphism>) => traverse_traversable_111; + (of: Morphism>, fn: Morphism>): traverse_traversable_111; + <$SEL extends "11">(): (of: Morphism>, fn: Morphism>) => traverse_traversable_111; <$SEL extends "1">(): (of: Morphism>) => traverse_traversable_101; <$SEL extends "01">(): (_of: PH, fn: Morphism>) => traverse_traversable_011; (of: Morphism>): traverse_traversable_101; }; type traverse_list_101 = { - (fn: Morphism>): traverse_list_111; + (fn: Morphism>): traverse_list_111; }; type traverse_traversable_101 = { - (fn: Morphism>): traverse_traversable_111; + (fn: Morphism>): traverse_traversable_111; }; type traverse_list_011 = { - (of: Morphism>): traverse_list_111; + (of: Morphism>): traverse_list_111; }; type traverse_traversable_011 = { - (of: Morphism>): traverse_traversable_111; + (of: Morphism>): traverse_traversable_111; }; -type traverse_list_111 = Applicative; -type traverse_traversable_111 = Applicative>; +type traverse_list_111 = Applicative; +type traverse_traversable_111 = Applicative>; export = traverse; diff --git a/ramda/dist/src/unfold.d.ts b/ramda/dist/src/unfold.d.ts index de1b821..7e1b6c6 100644 --- a/ramda/dist/src/unfold.d.ts +++ b/ramda/dist/src/unfold.d.ts @@ -27,17 +27,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const unfold: unfold_00; type unfold_00 = { (_fn: PH, initial: T): unfold_01; - (fn: (seed: T) => [R, T] | false, initial: T): unfold_11; - <$SEL extends "11">(): (fn: (seed: T) => [R, T] | false, initial: T) => unfold_11; + (fn: (seed: T) => [R, T] | false, initial: T): unfold_11; + <$SEL extends "11">(): (fn: (seed: T) => [R, T] | false, initial: T) => unfold_11; <$SEL extends "1">(): (fn: (seed: T) => [R, T] | false) => unfold_10; <$SEL extends "01">(): (_fn: PH, initial: T) => unfold_01; (fn: (seed: T) => [R, T] | false): unfold_10; }; type unfold_10 = { - (initial: T): unfold_11; + (initial: T): unfold_11; }; type unfold_01 = { - (fn: (seed: T) => [R, T] | false): unfold_11; + (fn: (seed: T) => [R, T] | false): unfold_11; }; -type unfold_11 = R[]; +type unfold_11 = R[]; export = unfold; diff --git a/ramda/dist/src/useWith.d.ts b/ramda/dist/src/useWith.d.ts index 2639f8f..52f68bf 100644 --- a/ramda/dist/src/useWith.d.ts +++ b/ramda/dist/src/useWith.d.ts @@ -41,12 +41,12 @@ type useWith_00 = { (_after: PH, fns: [Morphism, Morphism, Morphism, Morphism, Morphism, Morphism]): useWith_6arity_01; (_after: PH, fns: Function[]): useWith_variadic_01; (after: () => R, fns: never[]): useWith_0arity_11; - (after: (v1: U1) => R, fns: [Morphism]): useWith_1arity_11; - (after: (v1: U1, v2: U2) => R, fns: [Morphism, Morphism]): useWith_2arity_11; - (after: (v1: U1, v2: U2, v3: U3) => R, fns: [Morphism, Morphism, Morphism]): useWith_3arity_11; - (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [Morphism, Morphism, Morphism, Morphism]): useWith_4arity_11; - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [Morphism, Morphism, Morphism, Morphism, Morphism]): useWith_5arity_11; - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [Morphism, Morphism, Morphism, Morphism, Morphism, Morphism]): useWith_6arity_11; + (after: (v1: U1) => R, fns: [Morphism]): useWith_1arity_11; + (after: (v1: U1, v2: U2) => R, fns: [Morphism, Morphism]): useWith_2arity_11; + (after: (v1: U1, v2: U2, v3: U3) => R, fns: [Morphism, Morphism, Morphism]): useWith_3arity_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [Morphism, Morphism, Morphism, Morphism]): useWith_4arity_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [Morphism, Morphism, Morphism, Morphism, Morphism]): useWith_5arity_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [Morphism, Morphism, Morphism, Morphism, Morphism, Morphism]): useWith_6arity_11; (after: Variadic, fns: Function[]): useWith_variadic_11; (after: () => R): useWith_0arity_10; (after: (v1: U1) => R): useWith_1arity_10; @@ -58,22 +58,22 @@ type useWith_00 = { <$SEL extends "11", $KIND extends "0arity">(): (after: () => R, fns: never[]) => useWith_0arity_11; <$SEL extends "1", $KIND extends "0arity">(): (after: () => R) => useWith_0arity_10; <$SEL extends "01", $KIND extends "0arity">(): (_after: PH, fns: never[]) => useWith_0arity_01; - <$SEL extends "11", $KIND extends "1arity">(): (after: (v1: U1) => R, fns: [Morphism]) => useWith_1arity_11; + <$SEL extends "11", $KIND extends "1arity">(): (after: (v1: U1) => R, fns: [Morphism]) => useWith_1arity_11; <$SEL extends "1", $KIND extends "1arity">(): (after: (v1: U1) => R) => useWith_1arity_10; <$SEL extends "01", $KIND extends "1arity">(): (_after: PH, fns: [Morphism]) => useWith_1arity_01; - <$SEL extends "11", $KIND extends "2arity">(): (after: (v1: U1, v2: U2) => R, fns: [Morphism, Morphism]) => useWith_2arity_11; + <$SEL extends "11", $KIND extends "2arity">(): (after: (v1: U1, v2: U2) => R, fns: [Morphism, Morphism]) => useWith_2arity_11; <$SEL extends "1", $KIND extends "2arity">(): (after: (v1: U1, v2: U2) => R) => useWith_2arity_10; <$SEL extends "01", $KIND extends "2arity">(): (_after: PH, fns: [Morphism, Morphism]) => useWith_2arity_01; - <$SEL extends "11", $KIND extends "3arity">(): (after: (v1: U1, v2: U2, v3: U3) => R, fns: [Morphism, Morphism, Morphism]) => useWith_3arity_11; + <$SEL extends "11", $KIND extends "3arity">(): (after: (v1: U1, v2: U2, v3: U3) => R, fns: [Morphism, Morphism, Morphism]) => useWith_3arity_11; <$SEL extends "1", $KIND extends "3arity">(): (after: (v1: U1, v2: U2, v3: U3) => R) => useWith_3arity_10; <$SEL extends "01", $KIND extends "3arity">(): (_after: PH, fns: [Morphism, Morphism, Morphism]) => useWith_3arity_01; - <$SEL extends "11", $KIND extends "4arity">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [Morphism, Morphism, Morphism, Morphism]) => useWith_4arity_11; + <$SEL extends "11", $KIND extends "4arity">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R, fns: [Morphism, Morphism, Morphism, Morphism]) => useWith_4arity_11; <$SEL extends "1", $KIND extends "4arity">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R) => useWith_4arity_10; <$SEL extends "01", $KIND extends "4arity">(): (_after: PH, fns: [Morphism, Morphism, Morphism, Morphism]) => useWith_4arity_01; - <$SEL extends "11", $KIND extends "5arity">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [Morphism, Morphism, Morphism, Morphism, Morphism]) => useWith_5arity_11; + <$SEL extends "11", $KIND extends "5arity">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R, fns: [Morphism, Morphism, Morphism, Morphism, Morphism]) => useWith_5arity_11; <$SEL extends "1", $KIND extends "5arity">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R) => useWith_5arity_10; <$SEL extends "01", $KIND extends "5arity">(): (_after: PH, fns: [Morphism, Morphism, Morphism, Morphism, Morphism]) => useWith_5arity_01; - <$SEL extends "11", $KIND extends "6arity">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [Morphism, Morphism, Morphism, Morphism, Morphism, Morphism]) => useWith_6arity_11; + <$SEL extends "11", $KIND extends "6arity">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R, fns: [Morphism, Morphism, Morphism, Morphism, Morphism, Morphism]) => useWith_6arity_11; <$SEL extends "1", $KIND extends "6arity">(): (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R) => useWith_6arity_10; <$SEL extends "01", $KIND extends "6arity">(): (_after: PH, fns: [Morphism, Morphism, Morphism, Morphism, Morphism, Morphism]) => useWith_6arity_01; <$SEL extends "11", $KIND extends "variadic">(): (after: Variadic, fns: Function[]) => useWith_variadic_11; @@ -85,22 +85,22 @@ type useWith_0arity_10 = { (fns: never[]): useWith_0arity_11; }; type useWith_1arity_10 = { - (fns: [Morphism]): useWith_1arity_11; + (fns: [Morphism]): useWith_1arity_11; }; type useWith_2arity_10 = { - (fns: [Morphism, Morphism]): useWith_2arity_11; + (fns: [Morphism, Morphism]): useWith_2arity_11; }; type useWith_3arity_10 = { - (fns: [Morphism, Morphism, Morphism]): useWith_3arity_11; + (fns: [Morphism, Morphism, Morphism]): useWith_3arity_11; }; type useWith_4arity_10 = { - (fns: [Morphism, Morphism, Morphism, Morphism]): useWith_4arity_11; + (fns: [Morphism, Morphism, Morphism, Morphism]): useWith_4arity_11; }; type useWith_5arity_10 = { - (fns: [Morphism, Morphism, Morphism, Morphism, Morphism]): useWith_5arity_11; + (fns: [Morphism, Morphism, Morphism, Morphism, Morphism]): useWith_5arity_11; }; type useWith_6arity_10 = { - (fns: [Morphism, Morphism, Morphism, Morphism, Morphism, Morphism]): useWith_6arity_11; + (fns: [Morphism, Morphism, Morphism, Morphism, Morphism, Morphism]): useWith_6arity_11; }; type useWith_variadic_10 = { (fns: Function[]): useWith_variadic_11; @@ -109,32 +109,32 @@ type useWith_0arity_01 = { (after: () => R): useWith_0arity_11; }; type useWith_1arity_01 = { - (after: (v1: U1) => R): useWith_1arity_11; + (after: (v1: U1) => R): useWith_1arity_11; }; type useWith_2arity_01 = { - (after: (v1: U1, v2: U2) => R): useWith_2arity_11; + (after: (v1: U1, v2: U2) => R): useWith_2arity_11; }; type useWith_3arity_01 = { - (after: (v1: U1, v2: U2, v3: U3) => R): useWith_3arity_11; + (after: (v1: U1, v2: U2, v3: U3) => R): useWith_3arity_11; }; type useWith_4arity_01 = { - (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R): useWith_4arity_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4) => R): useWith_4arity_11; }; type useWith_5arity_01 = { - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R): useWith_5arity_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5) => R): useWith_5arity_11; }; type useWith_6arity_01 = { - (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R): useWith_6arity_11; + (after: (v1: U1, v2: U2, v3: U3, v4: U4, v5: U5, v6: U6) => R): useWith_6arity_11; }; type useWith_variadic_01 = { (after: Variadic): useWith_variadic_11; }; type useWith_0arity_11 = CurriedFunction0; -type useWith_1arity_11 = CurriedFunction1; -type useWith_2arity_11 = CurriedFunction2; -type useWith_3arity_11 = CurriedFunction3; -type useWith_4arity_11 = CurriedFunction4; -type useWith_5arity_11 = CurriedFunction5; -type useWith_6arity_11 = CurriedFunction6; +type useWith_1arity_11 = CurriedFunction1; +type useWith_2arity_11 = CurriedFunction2; +type useWith_3arity_11 = CurriedFunction3; +type useWith_4arity_11 = CurriedFunction4; +type useWith_5arity_11 = CurriedFunction5; +type useWith_6arity_11 = CurriedFunction6; type useWith_variadic_11 = Variadic; export = useWith; diff --git a/ramda/dist/src/view.d.ts b/ramda/dist/src/view.d.ts index 86627cf..24beee7 100644 --- a/ramda/dist/src/view.d.ts +++ b/ramda/dist/src/view.d.ts @@ -24,17 +24,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const view: view_00; type view_00 = { (_lens: PH, target: U): view_01; - (lens: Lens, target: U): view_11; - <$SEL extends "11">(): (lens: Lens, target: U) => view_11; + (lens: Lens, target: U): view_11; + <$SEL extends "11">(): (lens: Lens, target: U) => view_11; <$SEL extends "1">(): (lens: Lens) => view_10; <$SEL extends "01">(): (_lens: PH, target: U) => view_01; (lens: Lens): view_10; }; type view_10 = { - (target: U): view_11; + (target: U): view_11; }; type view_01 = { - (lens: Lens): view_11; + (lens: Lens): view_11; }; -type view_11 = T; +type view_11 = T; export = view; diff --git a/ramda/dist/src/where.d.ts b/ramda/dist/src/where.d.ts index 7066d75..bcff12d 100644 --- a/ramda/dist/src/where.d.ts +++ b/ramda/dist/src/where.d.ts @@ -37,17 +37,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const where: where_00; type where_00 = { (_spec: PH, object: Dictionary): where_01; - (spec: Dictionary>, object: Dictionary): where_11; - <$SEL extends "11">(): (spec: Dictionary>, object: Dictionary) => where_11; + (spec: Dictionary>, object: Dictionary): where_11; + <$SEL extends "11">(): (spec: Dictionary>, object: Dictionary) => where_11; <$SEL extends "1">(): (spec: Dictionary>) => where_10; <$SEL extends "01">(): (_spec: PH, object: Dictionary) => where_01; (spec: Dictionary>): where_10; }; type where_10 = { - (object: Dictionary): where_11; + (object: Dictionary): where_11; }; type where_01 = { - (spec: Dictionary>): where_11; + (spec: Dictionary>): where_11; }; -type where_11 = boolean; +type where_11 = boolean; export = where; diff --git a/ramda/dist/src/whereEq.d.ts b/ramda/dist/src/whereEq.d.ts index b6c7287..9e12ea8 100644 --- a/ramda/dist/src/whereEq.d.ts +++ b/ramda/dist/src/whereEq.d.ts @@ -31,17 +31,17 @@ import { Placeholder as PH } from "./$placeholder"; declare const whereEq: whereEq_00; type whereEq_00 = { (_spec: PH, object: Dictionary): whereEq_01; - (spec: Dictionary, object: Dictionary): whereEq_11; - <$SEL extends "11">(): (spec: Dictionary, object: Dictionary) => whereEq_11; + (spec: Dictionary, object: Dictionary): whereEq_11; + <$SEL extends "11">(): (spec: Dictionary, object: Dictionary) => whereEq_11; <$SEL extends "1">(): (spec: Dictionary) => whereEq_10; <$SEL extends "01">(): (_spec: PH, object: Dictionary) => whereEq_01; (spec: Dictionary): whereEq_10; }; type whereEq_10 = { - (object: Dictionary): whereEq_11; + (object: Dictionary): whereEq_11; }; type whereEq_01 = { - (spec: Dictionary): whereEq_11; + (spec: Dictionary): whereEq_11; }; -type whereEq_11 = boolean; +type whereEq_11 = boolean; export = whereEq; diff --git a/ramda/dist/src/zipWith.d.ts b/ramda/dist/src/zipWith.d.ts index 1535177..6b6ad7b 100644 --- a/ramda/dist/src/zipWith.d.ts +++ b/ramda/dist/src/zipWith.d.ts @@ -29,10 +29,10 @@ type zipWith_000 = { (fn: (x: T, y: U) => R, _a: PH, b: List): zipWith_101; (_fn: PH, a: List, b: List): zipWith_011; (_fn: PH, _a: PH, b: List): zipWith_001; - (fn: (x: T, y: U) => R, a: List, b: List): zipWith_111; + (fn: (x: T, y: U) => R, a: List, b: List): zipWith_111; (_fn: PH, a: List): zipWith_010; (fn: (x: T, y: U) => R, a: List): zipWith_110; - <$SEL extends "111">(): (fn: (x: T, y: U) => R, a: List, b: List) => zipWith_111; + <$SEL extends "111">(): (fn: (x: T, y: U) => R, a: List, b: List) => zipWith_111; <$SEL extends "11">(): (fn: (x: T, y: U) => R, a: List) => zipWith_110; <$SEL extends "101">(): (fn: (x: T, y: U) => R, _a: PH, b: List) => zipWith_101; <$SEL extends "1">(): (fn: (x: T, y: U) => R) => zipWith_100; @@ -43,36 +43,36 @@ type zipWith_000 = { }; type zipWith_100 = { (_a: PH, b: List): zipWith_101; - (a: List, b: List): zipWith_111; - <$SEL extends "11">(): (a: List, b: List) => zipWith_111; + (a: List, b: List): zipWith_111; + <$SEL extends "11">(): (a: List, b: List) => zipWith_111; <$SEL extends "1">(): (a: List) => zipWith_110; <$SEL extends "01">(): (_a: PH, b: List) => zipWith_101; (a: List): zipWith_110; }; type zipWith_010 = { (_fn: PH, b: List): zipWith_011; - (fn: (x: T, y: U) => R, b: List): zipWith_111; - <$SEL extends "11">(): (fn: (x: T, y: U) => R, b: List) => zipWith_111; + (fn: (x: T, y: U) => R, b: List): zipWith_111; + <$SEL extends "11">(): (fn: (x: T, y: U) => R, b: List) => zipWith_111; <$SEL extends "1">(): (fn: (x: T, y: U) => R) => zipWith_110; <$SEL extends "01">(): (_fn: PH, b: List) => zipWith_011; (fn: (x: T, y: U) => R): zipWith_110; }; type zipWith_110 = { - (b: List): zipWith_111; + (b: List): zipWith_111; }; type zipWith_001 = { (_fn: PH, a: List): zipWith_011; - (fn: (x: T, y: U) => R, a: List): zipWith_111; - <$SEL extends "11">(): (fn: (x: T, y: U) => R, a: List) => zipWith_111; + (fn: (x: T, y: U) => R, a: List): zipWith_111; + <$SEL extends "11">(): (fn: (x: T, y: U) => R, a: List) => zipWith_111; <$SEL extends "1">(): (fn: (x: T, y: U) => R) => zipWith_101; <$SEL extends "01">(): (_fn: PH, a: List) => zipWith_011; (fn: (x: T, y: U) => R): zipWith_101; }; type zipWith_101 = { - (a: List): zipWith_111; + (a: List): zipWith_111; }; type zipWith_011 = { - (fn: (x: T, y: U) => R): zipWith_111; + (fn: (x: T, y: U) => R): zipWith_111; }; -type zipWith_111 = R[]; +type zipWith_111 = R[]; export = zipWith; diff --git a/templates/utils/create-curried-types.ts b/templates/utils/create-curried-types.ts index 835959f..38c8c79 100644 --- a/templates/utils/create-curried-types.ts +++ b/templates/utils/create-curried-types.ts @@ -89,18 +89,18 @@ export const create_curried_types = (name: string, type: dts.IFunctionType, sele const type_declarations = target_types.map((target_type, index) => { const type_generics = sort_generics( - parameters_generics - .filter((_, generics_index) => masks[index][generics_index] === '1') - .reduce( - // tslint:disable-next-line:ter-indent - (current_type_generics, filtered_parameter_generics) => - unique(current_type_generics.concat(filtered_parameter_generics)), - // tslint:disable-next-line:ter-indent - (index === target_types.length - 1) - ? return_generics - : [], - ), - ); + (index === target_types.length - 1) + ? return_generics + : parameters_generics + .filter((_, generics_index) => masks[index][generics_index] === '1') + .reduce( + // tslint:disable-next-line:ter-indent + (current_type_generics, filtered_parameter_generics) => + unique(current_type_generics.concat(filtered_parameter_generics)), + // tslint:disable-next-line:ter-indent + [], + ), + ); return dts.create_type_declaration({ name: get_curried_function_type_name(name, masks[index]), generics: type_generics, @@ -125,13 +125,22 @@ export const create_curried_types = (name: string, type: dts.IFunctionType, sele const return_type_declaration = type_declarations[reverse_masks[return_mask]]; const return_type_generics = return_type_declaration.generics! .map(generic => dts.create_general_type({name: generic.name})); + const used_parameters_generics = sort_generics(unique(used_parameters.reduce( + (current, parameter) => [ + ...current, + ...(parameter_index => (parameter_index === -1) + ? [] + : parameters_generics[parameter_index] + )(parameters.indexOf(parameter)), + ], + return_type_declaration.generics!, + ))).filter(generic => type_declaration.generics!.indexOf(generic) === -1); members.push( dts.create_object_member({ owned: dts.create_function_declaration({ name: undefined, type: dts.create_function_type({ - generics: return_type_declaration.generics!.filter(generic => - type_declaration.generics!.indexOf(generic) === -1), + generics: used_parameters_generics, parameters: used_parameters, return: return_mask.split('').every(x => x === '1') && (type_predicate_parameter !== null)