diff --git a/tests/baselines/reference/abstractClassUnionInstantiation.types b/tests/baselines/reference/abstractClassUnionInstantiation.types
index 19b4fcd646e7d..c1033ddb3938e 100644
--- a/tests/baselines/reference/abstractClassUnionInstantiation.types
+++ b/tests/baselines/reference/abstractClassUnionInstantiation.types
@@ -75,7 +75,7 @@ new cls3(); // should work
 >[ConcreteA, AbstractA, AbstractB].map(cls => new cls()) : any[]
 >                                                        : ^^^^^
 >[ConcreteA, AbstractA, AbstractB].map : <U>(callbackfn: (value: typeof ConcreteA | typeof AbstractA | typeof AbstractB, index: number, array: (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
->                                      : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                                      : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[ConcreteA, AbstractA, AbstractB] : (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]
 >                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >ConcreteA : typeof ConcreteA
@@ -85,7 +85,7 @@ new cls3(); // should work
 >AbstractB : typeof AbstractB
 >          : ^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: typeof ConcreteA | typeof AbstractA | typeof AbstractB, index: number, array: (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >cls => new cls() : (cls: typeof ConcreteA | typeof AbstractA | typeof AbstractB) => any
 >                 : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >cls : typeof ConcreteA | typeof AbstractA | typeof AbstractB
@@ -99,7 +99,7 @@ new cls3(); // should work
 >[AbstractA, AbstractB, ConcreteA].map(cls => new cls()) : any[]
 >                                                        : ^^^^^
 >[AbstractA, AbstractB, ConcreteA].map : <U>(callbackfn: (value: typeof ConcreteA | typeof AbstractA | typeof AbstractB, index: number, array: (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
->                                      : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                                      : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[AbstractA, AbstractB, ConcreteA] : (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]
 >                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >AbstractA : typeof AbstractA
@@ -109,7 +109,7 @@ new cls3(); // should work
 >ConcreteA : typeof ConcreteA
 >          : ^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: typeof ConcreteA | typeof AbstractA | typeof AbstractB, index: number, array: (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >cls => new cls() : (cls: typeof ConcreteA | typeof AbstractA | typeof AbstractB) => any
 >                 : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >cls : typeof ConcreteA | typeof AbstractA | typeof AbstractB
@@ -123,7 +123,7 @@ new cls3(); // should work
 >[ConcreteA, ConcreteB].map(cls => new cls()) : ConcreteA[]
 >                                             : ^^^^^^^^^^^
 >[ConcreteA, ConcreteB].map : <U>(callbackfn: (value: typeof ConcreteA, index: number, array: (typeof ConcreteA)[]) => U, thisArg?: any) => U[]
->                           : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                           : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[ConcreteA, ConcreteB] : (typeof ConcreteA)[]
 >                       : ^^^^^^^^^^^^^^^^^^^^
 >ConcreteA : typeof ConcreteA
@@ -131,7 +131,7 @@ new cls3(); // should work
 >ConcreteB : typeof ConcreteB
 >          : ^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: typeof ConcreteA, index: number, array: (typeof ConcreteA)[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >cls => new cls() : (cls: typeof ConcreteA) => ConcreteA
 >                 : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >cls : typeof ConcreteA
@@ -145,7 +145,7 @@ new cls3(); // should work
 >[AbstractA, AbstractB].map(cls => new cls()) : any[]
 >                                             : ^^^^^
 >[AbstractA, AbstractB].map : <U>(callbackfn: (value: typeof AbstractA | typeof AbstractB, index: number, array: (typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
->                           : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                           : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[AbstractA, AbstractB] : (typeof AbstractA | typeof AbstractB)[]
 >                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >AbstractA : typeof AbstractA
@@ -153,7 +153,7 @@ new cls3(); // should work
 >AbstractB : typeof AbstractB
 >          : ^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: typeof AbstractA | typeof AbstractB, index: number, array: (typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >cls => new cls() : (cls: typeof AbstractA | typeof AbstractB) => any
 >                 : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >cls : typeof AbstractA | typeof AbstractB
diff --git a/tests/baselines/reference/acceptSymbolAsWeakType.types b/tests/baselines/reference/acceptSymbolAsWeakType.types
index fb7de081382bc..d4bb065082c5b 100644
--- a/tests/baselines/reference/acceptSymbolAsWeakType.types
+++ b/tests/baselines/reference/acceptSymbolAsWeakType.types
@@ -105,11 +105,11 @@ wm.get(s);
 >wm.get(s) : boolean | undefined
 >          : ^^^^^^^^^^^^^^^^^^^
 >wm.get : (key: symbol) => boolean | undefined
->       : ^   ^^^^^^^^^^^^^^^^^^^^            
+>       : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >wm : WeakMap<symbol, boolean>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^
 >get : (key: symbol) => boolean | undefined
->    : ^   ^^^^^^^^^^^^^^^^^^^^            
+>    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s : symbol
 >  : ^^^^^^
 
@@ -139,11 +139,11 @@ wr.deref();
 >wr.deref() : symbol | undefined
 >           : ^^^^^^^^^^^^^^^^^^
 >wr.deref : () => symbol | undefined
->         : ^^^^^^^^^^^^            
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^
 >wr : WeakRef<symbol>
 >   : ^^^^^^^^^^^^^^^
 >deref : () => symbol | undefined
->      : ^^^^^^^^^^^^            
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^
 
 const f = new FinalizationRegistry(() => {});
 >f : FinalizationRegistry<unknown>
diff --git a/tests/baselines/reference/accessorsOverrideProperty8.types b/tests/baselines/reference/accessorsOverrideProperty8.types
index 33c2b8cf935d4..bf114790b488b 100644
--- a/tests/baselines/reference/accessorsOverrideProperty8.types
+++ b/tests/baselines/reference/accessorsOverrideProperty8.types
@@ -39,9 +39,9 @@ declare function classWithProperties<T extends { [key: string]: Types }, P exten
 
 const Base = classWithProperties({
 >Base : { new (): Base & Properties<{ readonly x: "boolean"; y: "string"; }>; prototype: Base & Properties<{ readonly x: "boolean"; y: "string"; }>; }
->     : ^^^^^^^^^^^^^^              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >classWithProperties({    get x() { return 'boolean' as const },    y: 'string',}, class Base {}) : { new (): Base & Properties<{ readonly x: "boolean"; y: "string"; }>; prototype: Base & Properties<{ readonly x: "boolean"; y: "string"; }>; }
->                                                                                                 : ^^^^^^^^^^^^^^              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >classWithProperties : <T extends { [key: string]: Types; }, P extends object>(properties: T, klass: AnyCtor<P>) => { new (): P & Properties<T>; prototype: P & Properties<T>; }
 >                    : ^ ^^^^^^^^^                         ^^ ^^^^^^^^^      ^^          ^^ ^^     ^^          ^^^^^                                                            
 >{    get x() { return 'boolean' as const },    y: 'string',} : { readonly x: "boolean"; y: "string"; }
diff --git a/tests/baselines/reference/amdLikeInputDeclarationEmit.types b/tests/baselines/reference/amdLikeInputDeclarationEmit.types
index 8c8e555cd2240..7f1cf023932d7 100644
--- a/tests/baselines/reference/amdLikeInputDeclarationEmit.types
+++ b/tests/baselines/reference/amdLikeInputDeclarationEmit.types
@@ -57,9 +57,9 @@ define("lib/ExtendedClass", ["deps/BaseClass"],
     
     const ExtendedClass = BaseClass.extends({
 >ExtendedClass : new () => { f: () => "something"; } & import("deps/BaseClass")
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^^^^^^^^ 
+>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >BaseClass.extends({        f: function() {            return "something";        }    }) : new () => { f: () => "something"; } & import("deps/BaseClass")
->                                                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^^^^^^^^ 
+>                                                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >BaseClass.extends : <A>(a: A) => new () => A & import("deps/BaseClass")
 >                  : ^ ^^ ^^ ^^^^^                     ^^^^^^^^^^^^^^^^ 
 >BaseClass : typeof import("deps/BaseClass")
@@ -96,7 +96,7 @@ define("lib/ExtendedClass", ["deps/BaseClass"],
 >exports : any
 >        : ^^^
 >ExtendedClass : new () => { f: () => "something"; } & import("deps/BaseClass")
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^^^^^^^^ 
+>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     return module.exports;
 >module.exports : any
diff --git a/tests/baselines/reference/anyInferenceAnonymousFunctions.types b/tests/baselines/reference/anyInferenceAnonymousFunctions.types
index bf1bc90630956..aa32f70f996f5 100644
--- a/tests/baselines/reference/anyInferenceAnonymousFunctions.types
+++ b/tests/baselines/reference/anyInferenceAnonymousFunctions.types
@@ -86,11 +86,11 @@ paired.map((c1) => c1.count);
 >paired.map((c1) => c1.count) : any[]
 >                             : ^^^^^
 >paired.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
->           : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>           : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >paired : any[]
 >       : ^^^^^
 >map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(c1) => c1.count : (c1: any) => any
 >                 : ^  ^^^^^^^^^^^^^
 >c1 : any
@@ -104,11 +104,11 @@ paired.map(function (c2) { return c2.count; });
 >paired.map(function (c2) { return c2.count; }) : any[]
 >                                               : ^^^^^
 >paired.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
->           : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>           : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >paired : any[]
 >       : ^^^^^
 >map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >function (c2) { return c2.count; } : (c2: any) => any
 >                                   : ^  ^^^^^^^^^^^^^
 >c2 : any
diff --git a/tests/baselines/reference/arrayAugment.types b/tests/baselines/reference/arrayAugment.types
index 6a91cbccca3cc..d9d62a0a52481 100644
--- a/tests/baselines/reference/arrayAugment.types
+++ b/tests/baselines/reference/arrayAugment.types
@@ -23,11 +23,11 @@ var y = x.split(4);
 >x.split(4) : string[][]
 >           : ^^^^^^^^^^
 >x.split : (parts: number) => string[][]
->        : ^     ^^      ^^^^^^^^^^^    
+>        : ^     ^^      ^^^^^^^^^^^^^^^
 >x : string[]
 >  : ^^^^^^^^
 >split : (parts: number) => string[][]
->      : ^     ^^      ^^^^^^^^^^^    
+>      : ^     ^^      ^^^^^^^^^^^^^^^
 >4 : 4
 >  : ^
 
diff --git a/tests/baselines/reference/arrayConcat2.types b/tests/baselines/reference/arrayConcat2.types
index b7eefc82f1c5f..df756cdf2d284 100644
--- a/tests/baselines/reference/arrayConcat2.types
+++ b/tests/baselines/reference/arrayConcat2.types
@@ -11,11 +11,11 @@ a.concat("hello", 'world');
 >a.concat("hello", 'world') : string[]
 >                           : ^^^^^^^^
 >a.concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
->         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a : string[]
 >  : ^^^^^^^^
 >concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >"hello" : "hello"
 >        : ^^^^^^^
 >'world' : "world"
@@ -25,11 +25,11 @@ a.concat('Hello');
 >a.concat('Hello') : string[]
 >                  : ^^^^^^^^
 >a.concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
->         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a : string[]
 >  : ^^^^^^^^
 >concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >'Hello' : "Hello"
 >        : ^^^^^^^
 
@@ -45,11 +45,11 @@ b.concat('hello');
 >b.concat('hello') : string[]
 >                  : ^^^^^^^^
 >b.concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
->         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >b : string[]
 >  : ^^^^^^^^
 >concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >'hello' : "hello"
 >        : ^^^^^^^
 
diff --git a/tests/baselines/reference/arrayConcat3.types b/tests/baselines/reference/arrayConcat3.types
index 74c353243d2fb..7903cd79dcbc9 100644
--- a/tests/baselines/reference/arrayConcat3.types
+++ b/tests/baselines/reference/arrayConcat3.types
@@ -20,11 +20,11 @@ function doStuff<T extends object, T1 extends T>(a: Array<Fn<T>>, b: Array<Fn<T1
 >b.concat(a) : Fn<T1>[]
 >            : ^^^^^^^^
 >b.concat : { (...items: ConcatArray<Fn<T1>>[]): Fn<T1>[]; (...items: (Fn<T1> | ConcatArray<Fn<T1>>)[]): Fn<T1>[]; }
->         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >b : Fn<T1>[]
 >  : ^^^^^^^^
 >concat : { (...items: ConcatArray<Fn<T1>>[]): Fn<T1>[]; (...items: (Fn<T1> | ConcatArray<Fn<T1>>)[]): Fn<T1>[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a : Fn<T>[]
 >  : ^^^^^^^
 }
diff --git a/tests/baselines/reference/arrayConcatMap.types b/tests/baselines/reference/arrayConcatMap.types
index cee995b54a3a9..c56f3d149c402 100644
--- a/tests/baselines/reference/arrayConcatMap.types
+++ b/tests/baselines/reference/arrayConcatMap.types
@@ -7,15 +7,15 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }])
 >[].concat([{ a: 1 }], [{ a: 2 }])          .map(b => b.a) : any[]
 >                                                          : ^^^^^
 >[].concat([{ a: 1 }], [{ a: 2 }])          .map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
->                                                : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                                                : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[].concat([{ a: 1 }], [{ a: 2 }]) : any[]
 >                                  : ^^^^^
 >[].concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
->          : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^  ^^^
+>          : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 >concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^
 >[{ a: 1 }] : { a: number; }[]
 >           : ^^^^^^^^^^^^^^^^
 >{ a: 1 } : { a: number; }
@@ -35,7 +35,7 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }])
 
           .map(b => b.a);
 >map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >b => b.a : (b: any) => any
 >         : ^ ^^^^^^^^^^^^^
 >b : any
diff --git a/tests/baselines/reference/arrayFilter.types b/tests/baselines/reference/arrayFilter.types
index af86c0263ff1a..b6c6d05ee960f 100644
--- a/tests/baselines/reference/arrayFilter.types
+++ b/tests/baselines/reference/arrayFilter.types
@@ -35,11 +35,11 @@ foo.filter(x => x.name); //should accepted all possible types not only boolean!
 >foo.filter(x => x.name) : { name: string; }[]
 >                        : ^^^^^^^^^^^^^^^^^^^
 >foo.filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
->           : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^  ^^^
+>           : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^
 >foo : { name: string; }[]
 >    : ^^^^^^^^^^^^^^^^^^^
 >filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x.name : (x: { name: string; }) => string
 >            : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : { name: string; }
diff --git a/tests/baselines/reference/arrayFind.types b/tests/baselines/reference/arrayFind.types
index 1e7527ada5e15..b1f9aff8e6429 100644
--- a/tests/baselines/reference/arrayFind.types
+++ b/tests/baselines/reference/arrayFind.types
@@ -40,12 +40,12 @@ const foundNumber: number | undefined = arrayOfStringsNumbersAndBooleans.find(is
 >            : ^^^^^^
 >arrayOfStringsNumbersAndBooleans.find(isNumber) : number
 >                                                : ^^^^^^
->arrayOfStringsNumbersAndBooleans.find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => unknown, thisArg?: any): (string | number | boolean) | undefined; }
->                                      : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^
+>arrayOfStringsNumbersAndBooleans.find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => unknown, thisArg?: any): string | number | boolean; }
+>                                      : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >arrayOfStringsNumbersAndBooleans : (string | number | boolean)[]
 >                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => unknown, thisArg?: any): (string | number | boolean) | undefined; }
->     : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^
+>find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => unknown, thisArg?: any): string | number | boolean; }
+>     : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >isNumber : (x: any) => x is number
 >         : ^ ^^   ^^^^^           
 
@@ -62,12 +62,12 @@ const readonlyFoundNumber: number | undefined = readonlyArrayOfStringsNumbersAnd
 >                    : ^^^^^^
 >readonlyArrayOfStringsNumbersAndBooleans.find(isNumber) : number
 >                                                        : ^^^^^^
->readonlyArrayOfStringsNumbersAndBooleans.find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => unknown, thisArg?: any): (string | number | boolean) | undefined; }
->                                              : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^
+>readonlyArrayOfStringsNumbersAndBooleans.find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => unknown, thisArg?: any): string | number | boolean; }
+>                                              : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >readonlyArrayOfStringsNumbersAndBooleans : readonly (string | number | boolean)[]
 >                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => unknown, thisArg?: any): (string | number | boolean) | undefined; }
->     : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^
+>find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => unknown, thisArg?: any): string | number | boolean; }
+>     : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >isNumber : (x: any) => x is number
 >         : ^ ^^   ^^^^^           
 
diff --git a/tests/baselines/reference/arrayFlatMap.types b/tests/baselines/reference/arrayFlatMap.types
index c47bef7b00b15..9e235a58c7a29 100644
--- a/tests/baselines/reference/arrayFlatMap.types
+++ b/tests/baselines/reference/arrayFlatMap.types
@@ -16,12 +16,12 @@ const readonlyArray: ReadonlyArray<number> = [];
 array.flatMap((): ReadonlyArray<number> => []); // ok
 >array.flatMap((): ReadonlyArray<number> => []) : number[]
 >                                               : ^^^^^^^^
->array.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]
->              : ^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^                 ^ ^^       ^^^^^^^^^^^^^  
+>array.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
+>              : ^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
->flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]
->        : ^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^                 ^ ^^       ^^^^^^^^^^^^^  
+>flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
+>        : ^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^
 >(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
 >                                : ^^^^^^                     
 >[] : undefined[]
@@ -30,12 +30,12 @@ array.flatMap((): ReadonlyArray<number> => []); // ok
 readonlyArray.flatMap((): ReadonlyArray<number> => []); // ok
 >readonlyArray.flatMap((): ReadonlyArray<number> => []) : number[]
 >                                                       : ^^^^^^^^
->readonlyArray.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]
->                      : ^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^                 ^ ^^       ^^^^^^^^^^^^^  
+>readonlyArray.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
+>                      : ^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^
 >readonlyArray : readonly number[]
 >              : ^^^^^^^^^^^^^^^^^
->flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]
->        : ^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^                 ^ ^^       ^^^^^^^^^^^^^  
+>flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
+>        : ^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^
 >(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
 >                                : ^^^^^^                     
 >[] : undefined[]
diff --git a/tests/baselines/reference/arrayFlatNoCrashInference.types b/tests/baselines/reference/arrayFlatNoCrashInference.types
index ef3ab69056ab1..8bbd51bbd00f1 100644
--- a/tests/baselines/reference/arrayFlatNoCrashInference.types
+++ b/tests/baselines/reference/arrayFlatNoCrashInference.types
@@ -13,11 +13,11 @@ function foo<T>(arr: T[], depth: number) {
 >arr.flat(depth) : FlatArray<T, 0 | 1 | -1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20>[]
 >                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >arr.flat : <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[]
->         : ^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^          ^  ^   
+>         : ^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >arr : T[]
 >    : ^^^
 >flat : <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[]
->     : ^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^          ^  ^   
+>     : ^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >depth : number
 >      : ^^^^^^
 }
diff --git a/tests/baselines/reference/arrayFlatNoCrashInferenceDeclarations.types b/tests/baselines/reference/arrayFlatNoCrashInferenceDeclarations.types
index fbe76e0ead3d9..05081a3f9f0cc 100644
--- a/tests/baselines/reference/arrayFlatNoCrashInferenceDeclarations.types
+++ b/tests/baselines/reference/arrayFlatNoCrashInferenceDeclarations.types
@@ -13,11 +13,11 @@ function foo<T>(arr: T[], depth: number) {
 >arr.flat(depth) : FlatArray<T, 0 | 1 | -1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20>[]
 >                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >arr.flat : <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[]
->         : ^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^          ^  ^   
+>         : ^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >arr : T[]
 >    : ^^^
 >flat : <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[]
->     : ^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^          ^  ^   
+>     : ^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >depth : number
 >      : ^^^^^^
 }
diff --git a/tests/baselines/reference/arrayFrom.types b/tests/baselines/reference/arrayFrom.types
index dd4a41a176eb7..d8c53ad231cb4 100644
--- a/tests/baselines/reference/arrayFrom.types
+++ b/tests/baselines/reference/arrayFrom.types
@@ -86,11 +86,11 @@ const result2: A[] = Array.from(inputA.values());
 >inputA.values() : IterableIterator<A>
 >                : ^^^^^^^^^^^^^^^^^^^
 >inputA.values : () => IterableIterator<A>
->              : ^^^^^^                 ^ 
+>              : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >inputA : A[]
 >       : ^^^
 >values : () => IterableIterator<A>
->       : ^^^^^^                 ^ 
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const result3: B[] = Array.from(inputA.values()); // expect error
 >result3 : B[]
@@ -106,11 +106,11 @@ const result3: B[] = Array.from(inputA.values()); // expect error
 >inputA.values() : IterableIterator<A>
 >                : ^^^^^^^^^^^^^^^^^^^
 >inputA.values : () => IterableIterator<A>
->              : ^^^^^^                 ^ 
+>              : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >inputA : A[]
 >       : ^^^
 >values : () => IterableIterator<A>
->       : ^^^^^^                 ^ 
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const result4: A[] = Array.from(inputB, ({ b }): A => ({ a: b }));
 >result4 : A[]
diff --git a/tests/baselines/reference/arraySlice.types b/tests/baselines/reference/arraySlice.types
index cb3db625c8856..afa95b1d8db89 100644
--- a/tests/baselines/reference/arraySlice.types
+++ b/tests/baselines/reference/arraySlice.types
@@ -9,11 +9,11 @@ arr.splice(1, 1);
 >arr.splice(1, 1) : string[] | number[]
 >                 : ^^^^^^^^^^^^^^^^^^^
 >arr.splice : { (start: number, deleteCount?: number): string[]; (start: number, deleteCount: number, ...items: string[]): string[]; } | { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }
->           : ^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^
+>           : ^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^
 >arr : string[] | number[]
 >    : ^^^^^^^^^^^^^^^^^^^
 >splice : { (start: number, deleteCount?: number): string[]; (start: number, deleteCount: number, ...items: string[]): string[]; } | { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }
->       : ^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^
 >1 : 1
 >  : ^
 >1 : 1
diff --git a/tests/baselines/reference/asyncYieldStarContextualType.types b/tests/baselines/reference/asyncYieldStarContextualType.types
index 5ebb8046ff4e8..1a74d90e887fe 100644
--- a/tests/baselines/reference/asyncYieldStarContextualType.types
+++ b/tests/baselines/reference/asyncYieldStarContextualType.types
@@ -66,11 +66,11 @@ async function* f(): AsyncGenerator<"NOT_FOUND_AUTHOR" | "NOT_FOUND_BOOK", BookW
 >authorPromise.then(mapper) : Promise<Result<Author, "NOT_FOUND_AUTHOR">>
 >                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >authorPromise.then : <TResult1 = Result<Author, "NOT_FOUND_AUTHOR">, TResult2 = never>(onfulfilled?: (value: Result<Author, "NOT_FOUND_AUTHOR">) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >authorPromise : Promise<Result<Author, "NOT_FOUND_AUTHOR">>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = Result<Author, "NOT_FOUND_AUTHOR">, TResult2 = never>(onfulfilled?: (value: Result<Author, "NOT_FOUND_AUTHOR">) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >mapper : <T>(result: Result<T, "NOT_FOUND_AUTHOR">) => Result<T, "NOT_FOUND_AUTHOR">
 >       : ^ ^^      ^^                             ^^^^^                             
 
@@ -87,11 +87,11 @@ async function* f(): AsyncGenerator<"NOT_FOUND_AUTHOR" | "NOT_FOUND_BOOK", BookW
 >authorPromise.then(mapper) : Promise<Result<Author, "NOT_FOUND_AUTHOR">>
 >                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >authorPromise.then : <TResult1 = Result<Author, "NOT_FOUND_AUTHOR">, TResult2 = never>(onfulfilled?: (value: Result<Author, "NOT_FOUND_AUTHOR">) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >authorPromise : Promise<Result<Author, "NOT_FOUND_AUTHOR">>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = Result<Author, "NOT_FOUND_AUTHOR">, TResult2 = never>(onfulfilled?: (value: Result<Author, "NOT_FOUND_AUTHOR">) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >mapper : <T>(result: Result<T, "NOT_FOUND_AUTHOR">) => Result<T, "NOT_FOUND_AUTHOR">
 >       : ^ ^^      ^^                             ^^^^^                             
 
diff --git a/tests/baselines/reference/awaitUnionPromise.types b/tests/baselines/reference/awaitUnionPromise.types
index cd03ea8a5c7e0..661a2c3999cd4 100644
--- a/tests/baselines/reference/awaitUnionPromise.types
+++ b/tests/baselines/reference/awaitUnionPromise.types
@@ -43,11 +43,11 @@ async function main() {
 >x.next1() : Promise<number | AsyncEnumeratorDone>
 >          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x.next1 : () => Promise<number | AsyncEnumeratorDone>
->        : ^^^^^^        ^^^^^^                       
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : IAsyncEnumerator<number>
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^
 >next1 : () => Promise<number | AsyncEnumeratorDone>
->      : ^^^^^^        ^^^^^^                       
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     let b = await x.next2();
 >b : number | AsyncEnumeratorDone
@@ -56,12 +56,12 @@ async function main() {
 >                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x.next2() : Promise<AsyncEnumeratorDone> | Promise<number>
 >          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->x.next2 : () => Promise<number> | Promise<AsyncEnumeratorDone>
->        : ^^^^^^        ^^^^^^                                
+>x.next2 : () => Promise<AsyncEnumeratorDone> | Promise<number>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : IAsyncEnumerator<number>
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^
->next2 : () => Promise<number> | Promise<AsyncEnumeratorDone>
->      : ^^^^^^        ^^^^^^                                
+>next2 : () => Promise<AsyncEnumeratorDone> | Promise<number>
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     let c = await x.next3();
 >c : number | {}
@@ -71,11 +71,11 @@ async function main() {
 >x.next3() : Promise<number | {}>
 >          : ^^^^^^^^^^^^^^^^^^^^
 >x.next3 : () => Promise<number | {}>
->        : ^^^^^^        ^^^^^^      
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : IAsyncEnumerator<number>
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^
 >next3 : () => Promise<number | {}>
->      : ^^^^^^        ^^^^^^      
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     let d = await x.next4();
 >d : number | { x: string; }
@@ -85,10 +85,10 @@ async function main() {
 >x.next4() : Promise<number | { x: string; }>
 >          : ^^^^^^^^^^^^^^^^^^^^^^      ^^^^
 >x.next4 : () => Promise<number | { x: string; }>
->        : ^^^^^^        ^^^^^^                  
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^
 >x : IAsyncEnumerator<number>
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^
 >next4 : () => Promise<number | { x: string; }>
->      : ^^^^^^        ^^^^^^                  
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^
 }
 
diff --git a/tests/baselines/reference/awaitedType.types b/tests/baselines/reference/awaitedType.types
index 76a46cf5574ff..a025b532bd444 100644
--- a/tests/baselines/reference/awaitedType.types
+++ b/tests/baselines/reference/awaitedType.types
@@ -802,7 +802,7 @@ async function mainFindMany() {
 >Promise.all(promises).then((results) => {    const first = results[0]    const second = results[1] // error  }) : Promise<void>
 >                                                                                                                : ^^^^^^^^^^^^^
 >Promise.all(promises).then : <TResult1 = [number], TResult2 = never>(onfulfilled?: (value: [number]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                           : ^        ^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                           : ^        ^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Promise.all(promises) : Promise<[number]>
 >                      : ^^^^^^^^^^^^^^^^^
 >Promise.all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>; <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>; }
@@ -814,7 +814,7 @@ async function mainFindMany() {
 >promises : readonly [Promise<number>]
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = [number], TResult2 = never>(onfulfilled?: (value: [number]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(results) => {    const first = results[0]    const second = results[1] // error  } : (results: [number]) => void
 >                                                                                    : ^       ^^^^^^^^^^^^^^^^^^^
 >results : [number]
diff --git a/tests/baselines/reference/bestChoiceType.types b/tests/baselines/reference/bestChoiceType.types
index 6d6879d6b5f97..2b0a3a974e312 100644
--- a/tests/baselines/reference/bestChoiceType.types
+++ b/tests/baselines/reference/bestChoiceType.types
@@ -7,7 +7,7 @@
 >(''.match(/ /) || []).map(s => s.toLowerCase()) : any[]
 >                                                : ^^^^^
 >(''.match(/ /) || []).map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[])
->                          : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^
+>                          : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^
 >(''.match(/ /) || []) : RegExpMatchArray | []
 >                      : ^^^^^^^^^^^^^^^^^^^^^
 >''.match(/ /) || [] : RegExpMatchArray | []
@@ -25,7 +25,7 @@
 >[] : []
 >   : ^^
 >map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[])
->    : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^
+>    : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^
 >s => s.toLowerCase() : (s: any) => any
 >                     : ^ ^^^^^^^^^^^^^
 >s : any
@@ -72,11 +72,11 @@ function f1() {
 >y.map(s => s.toLowerCase()) : any[]
 >                            : ^^^^^
 >y.map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[])
->      : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^
+>      : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^
 >y : RegExpMatchArray | []
 >  : ^^^^^^^^^^^^^^^^^^^^^
 >map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[])
->    : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^
+>    : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^
 >s => s.toLowerCase() : (s: any) => any
 >                     : ^ ^^^^^^^^^^^^^
 >s : any
@@ -124,11 +124,11 @@ function f2() {
 >y.map(s => s.toLowerCase()) : any[]
 >                            : ^^^^^
 >y.map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[])
->      : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^
+>      : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^
 >y : RegExpMatchArray | never[]
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[])
->    : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^
+>    : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^
 >s => s.toLowerCase() : (s: any) => any
 >                     : ^ ^^^^^^^^^^^^^
 >s : any
diff --git a/tests/baselines/reference/booleanFilterAnyArray.types b/tests/baselines/reference/booleanFilterAnyArray.types
index b76d7b0a4414b..8925f7d31779c 100644
--- a/tests/baselines/reference/booleanFilterAnyArray.types
+++ b/tests/baselines/reference/booleanFilterAnyArray.types
@@ -45,12 +45,12 @@ var xs = anys.filter(Bullean)
 >   : ^^^^^^^^
 >anys.filter(Bullean) : Ari<any>
 >                     : ^^^^^^^^
->anys.filter : { <S extends any>(cb1: (value: any) => value is S): any extends any ? Ari<any> : Ari<S>; (cb2: (value: any) => unknown): Ari<any>; }
->            : ^^^ ^^^^^^^^^^^^^^   ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^                              ^ ^^^   ^^^     ^^^^^^^^^^       ^^^    ^^^ ^^^
+>anys.filter : { <S extends any>(cb1: (value: any) => value is S): Ari<any>; (cb2: (value: any) => unknown): Ari<any>; }
+>            : ^^^ ^^^^^^^^^^^^^^   ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^     ^^^^^^^^^^       ^^^^^^^^^^^^^^
 >anys : Ari<any>
 >     : ^^^^^^^^
->filter : { <S extends any>(cb1: (value: any) => value is S): any extends any ? Ari<any> : Ari<S>; (cb2: (value: any) => unknown): Ari<any>; }
->       : ^^^ ^^^^^^^^^^^^^^   ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^                              ^ ^^^   ^^^     ^^^^^^^^^^       ^^^    ^^^ ^^^
+>filter : { <S extends any>(cb1: (value: any) => value is S): Ari<any>; (cb2: (value: any) => unknown): Ari<any>; }
+>       : ^^^ ^^^^^^^^^^^^^^   ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^     ^^^^^^^^^^       ^^^^^^^^^^^^^^
 >Bullean : BulleanConstructor
 >        : ^^^^^^^^^^^^^^^^^^
 
@@ -68,11 +68,11 @@ var ys = realanys.filter(Boolean)
 >realanys.filter(Boolean) : any[]
 >                         : ^^^^^
 >realanys.filter : { <S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S[]; (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any[]; }
->                : ^^^ ^^^^^^^^^^^^^^         ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^       ^^       ^^^   ^^^^^^  ^^^
+>                : ^^^ ^^^^^^^^^^^^^^         ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^
 >realanys : any[]
 >         : ^^^^^
 >filter : { <S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S[]; (predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any[]; }
->       : ^^^ ^^^^^^^^^^^^^^         ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^       ^^       ^^^   ^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^         ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^
 >Boolean : BooleanConstructor
 >        : ^^^^^^^^^^^^^^^^^^
 
@@ -100,11 +100,11 @@ var foor = foo.filter(x => x.name)
 >foo.filter(x => x.name) : { name: string; }[]
 >                        : ^^^^^^^^^^^^^^^^^^^
 >foo.filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
->           : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^  ^^^
+>           : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^
 >foo : { name: string; }[]
 >    : ^^^^^^^^^^^^^^^^^^^
 >filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x.name : (x: { name: string; }) => string
 >            : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : { name: string; }
@@ -126,7 +126,7 @@ var foos = [true, true, false, null].filter((thing): thing is boolean => thing !
 >[true, true, false, null].filter((thing): thing is boolean => thing !== null) : boolean[]
 >                                                                              : ^^^^^^^^^
 >[true, true, false, null].filter : { <S extends boolean>(predicate: (value: boolean, index: number, array: boolean[]) => value is S, thisArg?: any): S[]; (predicate: (value: boolean, index: number, array: boolean[]) => unknown, thisArg?: any): boolean[]; }
->                                 : ^^^ ^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^  ^^^
+>                                 : ^^^ ^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^
 >[true, true, false, null] : boolean[]
 >                          : ^^^^^^^^^
 >true : true
@@ -136,7 +136,7 @@ var foos = [true, true, false, null].filter((thing): thing is boolean => thing !
 >false : false
 >      : ^^^^^
 >filter : { <S extends boolean>(predicate: (value: boolean, index: number, array: boolean[]) => value is S, thisArg?: any): S[]; (predicate: (value: boolean, index: number, array: boolean[]) => unknown, thisArg?: any): boolean[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^
 >(thing): thing is boolean => thing !== null : (thing: boolean) => thing is boolean
 >                                            : ^     ^^^^^^^^^^^^^^                
 >thing : boolean
diff --git a/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.types b/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.types
index 17265f5b69a35..54e61196fb31b 100644
--- a/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.types
+++ b/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.types
@@ -55,19 +55,19 @@ class C extends B {
 >(new Chain(new A)).then(a => new B).then(b => new C).then(c => new B).then(b => new A) : Chain<C>
 >                                                                                       : ^^^^^^^^
 >(new Chain(new A)).then(a => new B).then(b => new C).then(c => new B).then : <S extends C>(cb: (x: C) => S) => Chain<S>
->                                                                           : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^      ^ 
+>                                                                           : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain(new A)).then(a => new B).then(b => new C).then(c => new B) : Chain<C>
 >                                                                      : ^^^^^^^^
 >(new Chain(new A)).then(a => new B).then(b => new C).then : <S extends C>(cb: (x: C) => S) => Chain<S>
->                                                          : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^      ^ 
+>                                                          : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain(new A)).then(a => new B).then(b => new C) : Chain<C>
 >                                                     : ^^^^^^^^
 >(new Chain(new A)).then(a => new B).then : <S extends B>(cb: (x: B) => S) => Chain<S>
->                                         : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^      ^ 
+>                                         : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain(new A)).then(a => new B) : Chain<B>
 >                                    : ^^^^^^^^
 >(new Chain(new A)).then : <S extends A>(cb: (x: A) => S) => Chain<S>
->                        : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^      ^ 
+>                        : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain(new A)) : Chain<A>
 >                   : ^^^^^^^^
 >new Chain(new A) : Chain<A>
@@ -79,7 +79,7 @@ class C extends B {
 >A : typeof A
 >  : ^^^^^^^^
 >then : <S extends A>(cb: (x: A) => S) => Chain<S>
->     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^      ^ 
+>     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^
 >a => new B : (a: A) => B
 >           : ^ ^^^^^^^^^
 >a : A
@@ -89,7 +89,7 @@ class C extends B {
 >B : typeof B
 >  : ^^^^^^^^
 >then : <S extends B>(cb: (x: B) => S) => Chain<S>
->     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^      ^ 
+>     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^
 >b => new C : (b: B) => C
 >           : ^ ^^^^^^^^^
 >b : B
@@ -99,7 +99,7 @@ class C extends B {
 >C : typeof C
 >  : ^^^^^^^^
 >then : <S extends C>(cb: (x: C) => S) => Chain<S>
->     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^      ^ 
+>     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^
 >c => new B : (c: C) => B
 >           : ^ ^^^^^^^^^
 >c : C
@@ -109,7 +109,7 @@ class C extends B {
 >B : typeof B
 >  : ^^^^^^^^
 >then : <S extends C>(cb: (x: C) => S) => Chain<S>
->     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^      ^ 
+>     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^
 >b => new A : (b: C) => A
 >           : ^ ^^^^^^^^^
 >b : C
diff --git a/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.types b/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.types
index f1d5c774bccdf..3408e1ee7be5e 100644
--- a/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.types
+++ b/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.types
@@ -30,7 +30,7 @@ class Chain<T> {
 >(new Chain(t)).then(tt => s).then(ss => t) : Chain<S>
 >                                           : ^^^^^^^^
 >(new Chain(t)).then(tt => s).then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
->                                  : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^      ^ 
+>                                  : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain(t)).then(tt => s) : Chain<S>
 >                             : ^^^^^^^^
 >(new Chain(t)).then : <S extends T>(cb: (x: T) => S) => Chain<S>
@@ -52,7 +52,7 @@ class Chain<T> {
 >s : S
 >  : ^
 >then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
->     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^      ^ 
+>     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >ss => t : (ss: S) => T
 >        : ^  ^^^^^^^^^
 >ss : S
@@ -65,7 +65,7 @@ class Chain<T> {
 >(new Chain(s)).then(ss => t) : Chain<S>
 >                             : ^^^^^^^^
 >(new Chain(s)).then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
->                    : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^      ^ 
+>                    : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain(s)) : Chain<S>
 >               : ^^^^^^^^
 >new Chain(s) : Chain<S>
@@ -75,7 +75,7 @@ class Chain<T> {
 >s : S
 >  : ^
 >then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
->     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^      ^ 
+>     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >ss => t : (ss: S) => T
 >        : ^  ^^^^^^^^^
 >ss : S
@@ -134,15 +134,15 @@ class Chain<T> {
 >(new Chain(s)).then(ss => s).then(ss => s).then(ss => s) : Chain<S>
 >                                                         : ^^^^^^^^
 >(new Chain(s)).then(ss => s).then(ss => s).then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
->                                                : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^      ^ 
+>                                                : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain(s)).then(ss => s).then(ss => s) : Chain<S>
 >                                           : ^^^^^^^^
 >(new Chain(s)).then(ss => s).then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
->                                  : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^      ^ 
+>                                  : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain(s)).then(ss => s) : Chain<S>
 >                             : ^^^^^^^^
 >(new Chain(s)).then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
->                    : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^      ^ 
+>                    : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain(s)) : Chain<S>
 >               : ^^^^^^^^
 >new Chain(s) : Chain<S>
@@ -152,7 +152,7 @@ class Chain<T> {
 >s : S
 >  : ^
 >then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
->     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^      ^ 
+>     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >ss => s : (ss: S) => S
 >        : ^  ^^^^^^^^^
 >ss : S
@@ -160,7 +160,7 @@ class Chain<T> {
 >s : S
 >  : ^
 >then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
->     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^      ^ 
+>     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >ss => s : (ss: S) => S
 >        : ^  ^^^^^^^^^
 >ss : S
@@ -168,7 +168,7 @@ class Chain<T> {
 >s : S
 >  : ^
 >then : <S extends S_1>(cb: (x: S_1) => S) => Chain<S>
->     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^      ^ 
+>     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >ss => s : (ss: S) => S
 >        : ^  ^^^^^^^^^
 >ss : S
@@ -230,7 +230,7 @@ class Chain2<T extends I> {
 >(new Chain2(i)).then(ii => t) : Chain2<T>
 >                              : ^^^^^^^^^
 >(new Chain2(i)).then : <S extends I>(cb: (x: I) => S) => Chain2<S>
->                     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^       ^ 
+>                     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain2(i)) : Chain2<I>
 >                : ^^^^^^^^^
 >new Chain2(i) : Chain2<I>
@@ -240,7 +240,7 @@ class Chain2<T extends I> {
 >i : I
 >  : ^
 >then : <S extends I>(cb: (x: I) => S) => Chain2<S>
->     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^       ^ 
+>     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
 >ii => t : (ii: I) => T
 >        : ^  ^^^^^^^^^
 >ii : I
@@ -286,7 +286,7 @@ class Chain2<T extends I> {
 >(new Chain2(i)).then(ii => t) : Chain2<T>
 >                              : ^^^^^^^^^
 >(new Chain2(i)).then : <S extends I>(cb: (x: I) => S) => Chain2<S>
->                     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^       ^ 
+>                     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain2(i)) : Chain2<I>
 >                : ^^^^^^^^^
 >new Chain2(i) : Chain2<I>
@@ -296,7 +296,7 @@ class Chain2<T extends I> {
 >i : I
 >  : ^
 >then : <S extends I>(cb: (x: I) => S) => Chain2<S>
->     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^       ^ 
+>     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
 >ii => t : (ii: I) => T
 >        : ^  ^^^^^^^^^
 >ii : I
@@ -344,19 +344,19 @@ class Chain2<T extends I> {
 >(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then(ss => s) : Chain2<S>
 >                                                                        : ^^^^^^^^^
 >(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then : <S extends S_1>(cb: (x: S_1) => S) => Chain2<S>
->                                                               : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^       ^ 
+>                                                               : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s) : Chain2<S>
 >                                                          : ^^^^^^^^^
 >(new Chain2(i)).then(ii => s).then(ss => s).then : <S extends S_1>(cb: (x: S_1) => S) => Chain2<S>
->                                                 : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^       ^ 
+>                                                 : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain2(i)).then(ii => s).then(ss => s) : Chain2<S>
 >                                            : ^^^^^^^^^
 >(new Chain2(i)).then(ii => s).then : <S extends S_1>(cb: (x: S_1) => S) => Chain2<S>
->                                   : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^       ^ 
+>                                   : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain2(i)).then(ii => s) : Chain2<S>
 >                              : ^^^^^^^^^
 >(new Chain2(i)).then : <S extends I>(cb: (x: I) => S) => Chain2<S>
->                     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^       ^ 
+>                     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
 >(new Chain2(i)) : Chain2<I>
 >                : ^^^^^^^^^
 >new Chain2(i) : Chain2<I>
@@ -366,7 +366,7 @@ class Chain2<T extends I> {
 >i : I
 >  : ^
 >then : <S extends I>(cb: (x: I) => S) => Chain2<S>
->     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^       ^ 
+>     : ^ ^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
 >ii => s : (ii: I) => S
 >        : ^  ^^^^^^^^^
 >ii : I
@@ -374,7 +374,7 @@ class Chain2<T extends I> {
 >s : S
 >  : ^
 >then : <S extends S_1>(cb: (x: S_1) => S) => Chain2<S>
->     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^       ^ 
+>     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >ss => s : (ss: S) => S
 >        : ^  ^^^^^^^^^
 >ss : S
@@ -382,7 +382,7 @@ class Chain2<T extends I> {
 >s : S
 >  : ^
 >then : <S extends S_1>(cb: (x: S_1) => S) => Chain2<S>
->     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^       ^ 
+>     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >ss => s : (ss: S) => S
 >        : ^  ^^^^^^^^^
 >ss : S
@@ -390,7 +390,7 @@ class Chain2<T extends I> {
 >s : S
 >  : ^
 >then : <S extends S_1>(cb: (x: S_1) => S) => Chain2<S>
->     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^       ^ 
+>     : ^ ^^^^^^^^^^^^^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >ss => s : (ss: S) => S
 >        : ^  ^^^^^^^^^
 >ss : S
diff --git a/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.types b/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.types
index d4af00e7e1d91..4b1ad3adb8e28 100644
--- a/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.types
+++ b/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.types
@@ -49,11 +49,11 @@ var s2 = s.groupBy(s => s.length);
 >s.groupBy(s => s.length) : Sequence<{ key: number; items: string[]; }>
 >                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s.groupBy : <K>(keySelector: (value: string) => K) => Sequence<{ key: K; items: string[]; }>
->          : ^ ^^           ^^^     ^^^^^^^^^^^^^^^^^^^                ^         ^^^^^^      
+>          : ^ ^^           ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s : Sequence<string>
 >  : ^^^^^^^^^^^^^^^^
 >groupBy : <K>(keySelector: (value: string) => K) => Sequence<{ key: K; items: string[]; }>
->        : ^ ^^           ^^^     ^^^^^^^^^^^^^^^^^^^                ^         ^^^^^^      
+>        : ^ ^^           ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s => s.length : (s: string) => number
 >              : ^ ^^^^^^^^^^^^^^^^^^^
 >s : string
diff --git a/tests/baselines/reference/circularInstantiationExpression.types b/tests/baselines/reference/circularInstantiationExpression.types
index 9d171b86ba3cc..e5e41230272e1 100644
--- a/tests/baselines/reference/circularInstantiationExpression.types
+++ b/tests/baselines/reference/circularInstantiationExpression.types
@@ -10,8 +10,8 @@ declare function foo<T>(t: T): typeof foo<T>;
 >    : ^ ^^ ^^ ^^^^^             
 
 foo("");
->foo("") : (t: string) => typeof foo<string>
->        : ^ ^^^^^^^^^^^^^           ^^^^^^ 
+>foo("") : (t: string) => any
+>        : ^ ^^^^^^^^^^^^^^^^
 >foo : <T>(t: T) => typeof foo<T>
 >    : ^ ^^ ^^ ^^^^^             
 >"" : ""
diff --git a/tests/baselines/reference/circularReferenceInReturnType.types b/tests/baselines/reference/circularReferenceInReturnType.types
index 11eeca7eb191a..78610ee8daec7 100644
--- a/tests/baselines/reference/circularReferenceInReturnType.types
+++ b/tests/baselines/reference/circularReferenceInReturnType.types
@@ -34,7 +34,7 @@ const res2 = fn2()(() => res2);
 >fn2()(() => res2) : (a: unknown) => void
 >                  : ^ ^^^^^^^^^^^^^^    
 >fn2() : (cb: () => any) => (a: unknown) => void
->      : ^  ^^         ^^^^^    ^^^^^^^         
+>      : ^  ^^         ^^^^^^ ^^^^^^^^^^^^^^    
 >fn2 : <T>() => (cb: () => any) => (a: T) => void
 >    : ^ ^^^^^^^                                 
 >() => res2 : () => (a: unknown) => void
@@ -58,7 +58,7 @@ const res3 = fn3()(() => res3);
 >fn3()(() => res3) : (a: unknown) => void
 >                  : ^ ^^^^^^^^^^^^^^    
 >fn3() : <T2>(cb: (arg: T2) => any) => (a: unknown) => void
->      : ^  ^^  ^^^   ^^^^^^^^^   ^^^^^    ^^^^^^^         
+>      : ^  ^^  ^^^   ^^^^^^^^^   ^^^^^^ ^^^^^^^^^^^^^^    
 >fn3 : <T>() => <T2>(cb: (arg: T2) => any) => (a: T) => void
 >    : ^ ^^^^^^^                                            
 >() => res3 : () => (a: unknown) => void
diff --git a/tests/baselines/reference/circularReferenceInReturnType2.types b/tests/baselines/reference/circularReferenceInReturnType2.types
index 53a5ae6890bac..11979f1777346 100644
--- a/tests/baselines/reference/circularReferenceInReturnType2.types
+++ b/tests/baselines/reference/circularReferenceInReturnType2.types
@@ -109,7 +109,7 @@ const A = object<Something>()({
 >object<Something>()({  name: "A",  fields: () => ({    a: field({      type: A,      resolve() {        return {          foo: 100,        };      },    }),  }),}) : ObjectType<Something>
 >                                                                                                                                                                    : ^^^^^^^^^^^^^^^^^^^^^
 >object<Something>() : <Fields extends { [Key in keyof Fields]: Field<Something, Key & string>; }>(config: { name: string; fields: Fields | (() => Fields); }) => ObjectType<Something>
->                    : ^      ^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^           ^^^^^^^^^ 
+>                    : ^      ^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >object : <Source>() => <Fields extends { [Key in keyof Fields]: Field<Source, Key & string>; }>(config: { name: string; fields: Fields | (() => Fields); }) => ObjectType<Source>
 >       : ^      ^^^^^^^                                                                                                                                                          
 >{  name: "A",  fields: () => ({    a: field({      type: A,      resolve() {        return {          foo: 100,        };      },    }),  }),} : { name: string; fields: () => any; }
diff --git a/tests/baselines/reference/classReferencedInContextualParameterWithinItsOwnBaseExpression.types b/tests/baselines/reference/classReferencedInContextualParameterWithinItsOwnBaseExpression.types
index 2a33527349c2c..0b3d3b72e0c27 100644
--- a/tests/baselines/reference/classReferencedInContextualParameterWithinItsOwnBaseExpression.types
+++ b/tests/baselines/reference/classReferencedInContextualParameterWithinItsOwnBaseExpression.types
@@ -65,7 +65,7 @@ export class A extends Class<A>("A")(
 >Class<A>("A")(  { a: string },  {    pretty: (a) => JSON.stringify(a),  },) : OutputFrom<{ a: () => Type<string>; }>
 >                                                                            : ^^^^^^^^^^^^^^^^^^^^^^            ^^^^
 >Class<A>("A") : <Fields>(fields: Fields, annotations?: Schema<A> | undefined) => Class<OutputFrom<Fields>>
->              : ^      ^^      ^^^^^^^^^^           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^  
+>              : ^      ^^      ^^^^^^^^^^           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Class : <Self>(identifier: string) => <Fields>(fields: Fields, annotations?: Schema<Self>) => Class<OutputFrom<Fields>>
 >      : ^    ^^          ^^      ^^^^^                                                                                 
 >"A" : "A"
diff --git a/tests/baselines/reference/classStaticBlock23(target=es2022).types b/tests/baselines/reference/classStaticBlock23(target=es2022).types
index 1b54fca881781..b42d8ee9f9e1d 100644
--- a/tests/baselines/reference/classStaticBlock23(target=es2022).types
+++ b/tests/baselines/reference/classStaticBlock23(target=es2022).types
@@ -7,7 +7,7 @@ const nums = [1, 2, 3].map(n => Promise.resolve(n))
 >[1, 2, 3].map(n => Promise.resolve(n)) : Promise<number>[]
 >                                       : ^^^^^^^^^^^^^^^^^
 >[1, 2, 3].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->              : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>              : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1, 2, 3] : number[]
 >          : ^^^^^^^^
 >1 : 1
@@ -17,7 +17,7 @@ const nums = [1, 2, 3].map(n => Promise.resolve(n))
 >3 : 3
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >n => Promise.resolve(n) : (n: number) => Promise<number>
 >                        : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >n : number
diff --git a/tests/baselines/reference/classStaticBlock23(target=esnext).types b/tests/baselines/reference/classStaticBlock23(target=esnext).types
index 1b54fca881781..b42d8ee9f9e1d 100644
--- a/tests/baselines/reference/classStaticBlock23(target=esnext).types
+++ b/tests/baselines/reference/classStaticBlock23(target=esnext).types
@@ -7,7 +7,7 @@ const nums = [1, 2, 3].map(n => Promise.resolve(n))
 >[1, 2, 3].map(n => Promise.resolve(n)) : Promise<number>[]
 >                                       : ^^^^^^^^^^^^^^^^^
 >[1, 2, 3].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->              : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>              : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1, 2, 3] : number[]
 >          : ^^^^^^^^
 >1 : 1
@@ -17,7 +17,7 @@ const nums = [1, 2, 3].map(n => Promise.resolve(n))
 >3 : 3
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >n => Promise.resolve(n) : (n: number) => Promise<number>
 >                        : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >n : number
diff --git a/tests/baselines/reference/coAndContraVariantInferences3.types b/tests/baselines/reference/coAndContraVariantInferences3.types
index 05ff762589fd9..30b29ccb9ebbe 100644
--- a/tests/baselines/reference/coAndContraVariantInferences3.types
+++ b/tests/baselines/reference/coAndContraVariantInferences3.types
@@ -292,16 +292,16 @@ declare const DISALLOW_DECORATORS: DeprecationOptions;
 buildOverload("updateImportDeclaration")
 >buildOverload("updateImportDeclaration")    .overload({        0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },        1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },    })    .bind({        0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) =>            (other === undefined) &&            (modifiers === undefined || every(modifiers, isModifier)) &&            (importClause === undefined || !isArray(importClause)) &&            (moduleSpecifier === undefined || isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),        1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) =>            (decorators === undefined || every(decorators, isDecorator)) &&            (modifiers === undefined || isArray(modifiers)) &&            (importClause === undefined || isImportClause(importClause)) &&            (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),    })    .deprecate({        1: DISALLOW_DECORATORS    })    .finish() : ((node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined) => ImportDeclaration) & ((node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined) => ImportDeclaration)
 >                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 : ^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^^^                 ^^^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^^^                 ^
->buildOverload("updateImportDeclaration")    .overload({        0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },        1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },    })    .bind({        0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) =>            (other === undefined) &&            (modifiers === undefined || every(modifiers, isModifier)) &&            (importClause === undefined || !isArray(importClause)) &&            (moduleSpecifier === undefined || isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),        1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) =>            (decorators === undefined || every(decorators, isDecorator)) &&            (modifiers === undefined || isArray(modifiers)) &&            (importClause === undefined || isImportClause(importClause)) &&            (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),    })    .deprecate({        1: DISALLOW_DECORATORS    })    .finish : () => OverloadFunction<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
->                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               : ^^^^^^                 ^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^ 
+>buildOverload("updateImportDeclaration")    .overload({        0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },        1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },    })    .bind({        0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) =>            (other === undefined) &&            (modifiers === undefined || every(modifiers, isModifier)) &&            (importClause === undefined || !isArray(importClause)) &&            (moduleSpecifier === undefined || isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),        1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) =>            (decorators === undefined || every(decorators, isDecorator)) &&            (modifiers === undefined || isArray(modifiers)) &&            (importClause === undefined || isImportClause(importClause)) &&            (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),    })    .deprecate({        1: DISALLOW_DECORATORS    })    .finish : () => ((node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined) => ImportDeclaration) & ((node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined) => ImportDeclaration)
+>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               : ^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^^^                 ^^^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^^^                 ^
 >buildOverload("updateImportDeclaration")    .overload({        0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },        1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },    })    .bind({        0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) =>            (other === undefined) &&            (modifiers === undefined || every(modifiers, isModifier)) &&            (importClause === undefined || !isArray(importClause)) &&            (moduleSpecifier === undefined || isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),        1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) =>            (decorators === undefined || every(decorators, isDecorator)) &&            (modifiers === undefined || isArray(modifiers)) &&            (importClause === undefined || isImportClause(importClause)) &&            (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),    })    .deprecate({        1: DISALLOW_DECORATORS    }) : FinishableOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
 >                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^
 >buildOverload("updateImportDeclaration")    .overload({        0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },        1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },    })    .bind({        0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) =>            (other === undefined) &&            (modifiers === undefined || every(modifiers, isModifier)) &&            (importClause === undefined || !isArray(importClause)) &&            (moduleSpecifier === undefined || isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),        1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) =>            (decorators === undefined || every(decorators, isDecorator)) &&            (modifiers === undefined || isArray(modifiers)) &&            (importClause === undefined || isImportClause(importClause)) &&            (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),    })    .deprecate : (deprecations: OverloadDeprecations<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>) => FinishableOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
->                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              : ^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^^^^^^                          ^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^ 
+>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              : ^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^
 >buildOverload("updateImportDeclaration")    .overload({        0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },        1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },    })    .bind({        0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) =>            (other === undefined) &&            (modifiers === undefined || every(modifiers, isModifier)) &&            (importClause === undefined || !isArray(importClause)) &&            (moduleSpecifier === undefined || isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),        1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) =>            (decorators === undefined || every(decorators, isDecorator)) &&            (modifiers === undefined || isArray(modifiers)) &&            (importClause === undefined || isImportClause(importClause)) &&            (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),    }) : BoundOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
 >                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^
 >buildOverload("updateImportDeclaration")    .overload({        0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },        1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },    })    .bind : (binder: OverloadBinders<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>) => BoundOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
->                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            : ^      ^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^^^^^^                     ^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^ 
+>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            : ^      ^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^
 >buildOverload("updateImportDeclaration")    .overload({        0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },        1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration {            return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause);        },    }) : BindableOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
 >                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^
 >buildOverload("updateImportDeclaration")    .overload : <T extends OverloadDefinitions>(overloads: T) => BindableOverloadBuilder<T>
@@ -387,7 +387,7 @@ buildOverload("updateImportDeclaration")
     })
     .bind({
 >bind : (binder: OverloadBinders<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>) => BoundOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
->     : ^      ^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^^^^^^                     ^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^ 
+>     : ^      ^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^
 >{        0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) =>            (other === undefined) &&            (modifiers === undefined || every(modifiers, isModifier)) &&            (importClause === undefined || !isArray(importClause)) &&            (moduleSpecifier === undefined || isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),        1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) =>            (decorators === undefined || every(decorators, isDecorator)) &&            (modifiers === undefined || isArray(modifiers)) &&            (importClause === undefined || isImportClause(importClause)) &&            (moduleSpecifier !== undefined && isExpression(moduleSpecifier)) &&            (assertClause === undefined || isAssertClause(assertClause)),    } : { 0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]: [node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined] | [node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined]) => boolean; 1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]: [node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined] | [node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined]) => boolean; }
 >                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   : ^^^^^^                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -624,7 +624,7 @@ buildOverload("updateImportDeclaration")
     })
     .deprecate({
 >deprecate : (deprecations: OverloadDeprecations<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>) => FinishableOverloadBuilder<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
->          : ^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^^^^^^                          ^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^ 
+>          : ^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^
 >{        1: DISALLOW_DECORATORS    } : { 1: DeprecationOptions; }
 >                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -636,8 +636,8 @@ buildOverload("updateImportDeclaration")
 
     })
     .finish();
->finish : () => OverloadFunction<{ 0(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; 1(node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration; }>
->       : ^^^^^^                 ^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^                 ^^^ 
+>finish : () => ((node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined) => ImportDeclaration) & ((node: ImportDeclaration, _decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined) => ImportDeclaration)
+>       : ^^^^^^^^    ^^                 ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^^^                 ^^^^^^    ^^                 ^^           ^^                                ^^         ^^                               ^^            ^^                        ^^               ^^          ^^            ^^                        ^^^^^                 ^
 
 
 declare const modifiers: readonly Modifier[] | readonly Decorator[];
diff --git a/tests/baselines/reference/collectionPatternNoError.types b/tests/baselines/reference/collectionPatternNoError.types
index d85d37eb1bbe5..14f62d0689bbf 100644
--- a/tests/baselines/reference/collectionPatternNoError.types
+++ b/tests/baselines/reference/collectionPatternNoError.types
@@ -73,11 +73,11 @@ class DataProvider<T extends Message, U extends MessageList<T>> {
 >messageList.methodOnMessageList() : T[]
 >                                  : ^^^
 >messageList.methodOnMessageList : () => T[]
->                                : ^^^^^^^  
+>                                : ^^^^^^^^^
 >messageList : U
 >            : ^
 >methodOnMessageList : () => T[]
->                    : ^^^^^^^  
+>                    : ^^^^^^^^^
   }
 }
 
@@ -102,7 +102,7 @@ function f<
 >fetchMsg(messageList).methodOnMessageList() : T[]
 >                                            : ^^^
 >fetchMsg(messageList).methodOnMessageList : () => T[]
->                                          : ^^^^^^^  
+>                                          : ^^^^^^^^^
 >fetchMsg(messageList) : U["TType"]
 >                      : ^^^^^^^^^^
 >fetchMsg : <V extends Message>(protoCtor: MsgConstructor<V>) => V
@@ -110,6 +110,6 @@ function f<
 >messageList : MsgConstructor<U["TType"]>
 >            : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >methodOnMessageList : () => T[]
->                    : ^^^^^^^  
+>                    : ^^^^^^^^^
 }
 
diff --git a/tests/baselines/reference/commaOperatorInConditionalExpression.types b/tests/baselines/reference/commaOperatorInConditionalExpression.types
index 1bf0a1b820f49..edf5514a3b631 100644
--- a/tests/baselines/reference/commaOperatorInConditionalExpression.types
+++ b/tests/baselines/reference/commaOperatorInConditionalExpression.types
@@ -11,7 +11,7 @@ function f (m: string) {
 >[1, 2, 3].map(i => {        return true? { [m]: i } : { [m]: i + 1 }    }) : { [x: string]: number; }[]
 >                                                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->              : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>              : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1, 2, 3] : number[]
 >          : ^^^^^^^^
 >1 : 1
@@ -21,7 +21,7 @@ function f (m: string) {
 >3 : 3
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >i => {        return true? { [m]: i } : { [m]: i + 1 }    } : (i: number) => { [x: string]: number; }
 >                                                            : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >i : number
diff --git a/tests/baselines/reference/commentInMethodCall.types b/tests/baselines/reference/commentInMethodCall.types
index 100fe86b3727c..27d91df643226 100644
--- a/tests/baselines/reference/commentInMethodCall.types
+++ b/tests/baselines/reference/commentInMethodCall.types
@@ -10,11 +10,11 @@ s.map(// do something
 >s.map(// do something    function () { }) : void[]
 >                                          : ^^^^^^
 >s.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->      : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>      : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >s : string[]
 >  : ^^^^^^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 
     function () { });
 >function () { } : () => void
diff --git a/tests/baselines/reference/concatError.types b/tests/baselines/reference/concatError.types
index 116168a81693e..e4de328530b08 100644
--- a/tests/baselines/reference/concatError.types
+++ b/tests/baselines/reference/concatError.types
@@ -23,11 +23,11 @@ fa = fa.concat([0]);
 >fa.concat([0]) : number[]
 >               : ^^^^^^^^
 >fa.concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
->          : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>          : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >fa : number[]
 >   : ^^^^^^^^
 >concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[0] : number[]
 >    : ^^^^^^^^
 >0 : 0
@@ -41,11 +41,11 @@ fa = fa.concat(0);
 >fa.concat(0) : number[]
 >             : ^^^^^^^^
 >fa.concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
->          : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>          : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >fa : number[]
 >   : ^^^^^^^^
 >concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 
diff --git a/tests/baselines/reference/concatTuples.types b/tests/baselines/reference/concatTuples.types
index 2c2d51bba4bfb..bcf330f4e7ee9 100644
--- a/tests/baselines/reference/concatTuples.types
+++ b/tests/baselines/reference/concatTuples.types
@@ -21,11 +21,11 @@ ijs = ijs.concat([[3, 4], [5, 6]]);
 >ijs.concat([[3, 4], [5, 6]]) : [number, number][]
 >                             : ^^^^^^^^^^^^^^^^^^
 >ijs.concat : { (...items: ConcatArray<[number, number]>[]): [number, number][]; (...items: ([number, number] | ConcatArray<[number, number]>)[]): [number, number][]; }
->           : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>           : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >ijs : [number, number][]
 >    : ^^^^^^^^^^^^^^^^^^
 >concat : { (...items: ConcatArray<[number, number]>[]): [number, number][]; (...items: ([number, number] | ConcatArray<[number, number]>)[]): [number, number][]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[[3, 4], [5, 6]] : [number, number][]
 >                 : ^^^^^^^^^^^^^^^^^^
 >[3, 4] : [number, number]
diff --git a/tests/baselines/reference/contextualExpressionTypecheckingDoesntBlowStack.types b/tests/baselines/reference/contextualExpressionTypecheckingDoesntBlowStack.types
index 6f988422ddcb7..f9a158fc781e3 100644
--- a/tests/baselines/reference/contextualExpressionTypecheckingDoesntBlowStack.types
+++ b/tests/baselines/reference/contextualExpressionTypecheckingDoesntBlowStack.types
@@ -100,7 +100,7 @@ export default class Operation {
 >(result || []).concat(innerResult) : IValidationError[]
 >                                   : ^^^^^^^^^^^^^^^^^^
 >(result || []).concat : { (...items: ConcatArray<IValidationError>[]): IValidationError[]; (...items: (IValidationError | ConcatArray<IValidationError>)[]): IValidationError[]; }
->                      : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>                      : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(result || []) : IValidationError[]
 >               : ^^^^^^^^^^^^^^^^^^
 >result || [] : IValidationError[]
@@ -110,7 +110,7 @@ export default class Operation {
 >[] : never[]
 >   : ^^^^^^^
 >concat : { (...items: ConcatArray<IValidationError>[]): IValidationError[]; (...items: (IValidationError | ConcatArray<IValidationError>)[]): IValidationError[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >innerResult : any
             }
         }
diff --git a/tests/baselines/reference/contextualOverloadListFromArrayUnion.types b/tests/baselines/reference/contextualOverloadListFromArrayUnion.types
index 35c2a83ae6ebf..77298efc245ef 100644
--- a/tests/baselines/reference/contextualOverloadListFromArrayUnion.types
+++ b/tests/baselines/reference/contextualOverloadListFromArrayUnion.types
@@ -11,11 +11,11 @@ export const yThen = y.map(item => item.length);
 >y.map(item => item.length) : number[]
 >                           : ^^^^^^^^
 >y.map : (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[])
->      : ^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^
+>      : ^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^
 >y : never[] | string[]
 >  : ^^^^^^^^^^^^^^^^^^
 >map : (<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[])
->    : ^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^
+>    : ^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^
 >item => item.length : (item: string) => number
 >                    : ^    ^^^^^^^^^^^^^^^^^^^
 >item : string
@@ -38,11 +38,11 @@ export const yThen = y.map(item => item.length);
 >y.map(item => item.length) : number[]
 >                           : ^^^^^^^^
 >y.map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: number[], index: number, array: number[][]) => U, thisArg?: any) => U[])
->      : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^ ^^          ^^^     ^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^
+>      : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^ ^^          ^^^     ^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^
 >y : string[] | number[][]
 >  : ^^^^^^^^^^^^^^^^^^^^^
 >map : (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: number[], index: number, array: number[][]) => U, thisArg?: any) => U[])
->    : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^ ^^          ^^^     ^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^
+>    : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^ ^^          ^^^     ^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^
 >item => item.length : (item: string | number[]) => number
 >                    : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >item : string | number[]
diff --git a/tests/baselines/reference/contextualSignatureInstantiation1.types b/tests/baselines/reference/contextualSignatureInstantiation1.types
index 0d4d79d379a77..be3f6216221ae 100644
--- a/tests/baselines/reference/contextualSignatureInstantiation1.types
+++ b/tests/baselines/reference/contextualSignatureInstantiation1.types
@@ -29,9 +29,9 @@ var e = <K>(x: string, y?: K) => x.length;
 
 var r99 = map(e); // should be {}[] for S since a generic lambda is not inferentially typed
 >r99 : <K>(a: string[]) => number[]
->    : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^  
+>    : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
 >map(e) : <K>(a: string[]) => number[]
->       : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^  
+>       : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
 >map : <S, T>(f: (x: S) => T) => (a: S[]) => T[]
 >    : ^ ^^ ^^ ^^           ^^^^^               
 >e : <K>(x: string, y?: K) => number
@@ -67,9 +67,9 @@ var e2 = <K>(x: string, y?: K) => x.length;
 
 var r100 = map2(e2); // type arg inference should fail for S since a generic lambda is not inferentially typed. Falls back to { length: number }
 >r100 : <K>(a: string[]) => number[]
->     : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^  
+>     : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
 >map2(e2) : <K>(a: string[]) => number[]
->         : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^  
+>         : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
 >map2 : <S extends { length: number; }, T>(f: (x: S) => T) => (a: S[]) => T[]
 >     : ^ ^^^^^^^^^                   ^^ ^^ ^^           ^^^^^               
 >e2 : <K>(x: string, y?: K) => number
diff --git a/tests/baselines/reference/contextualSignatureInstantiation2.types b/tests/baselines/reference/contextualSignatureInstantiation2.types
index 4316ea4216b81..fac97d12fd2a1 100644
--- a/tests/baselines/reference/contextualSignatureInstantiation2.types
+++ b/tests/baselines/reference/contextualSignatureInstantiation2.types
@@ -62,7 +62,7 @@ var r23 = dot(id)(id);
 >dot(id)(id) : <T>(_: T) => unknown
 >            : ^ ^^ ^^^^^^^^^^^^^^^
 >dot(id) : <U>(g: (_: U) => unknown) => (_: U) => unknown
->        : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^    ^     ^^^^^^^
+>        : ^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
 >dot : <T, S>(f: (_: T) => S) => <U>(g: (_: U) => T) => (_: U) => S
 >    : ^ ^^ ^^ ^^           ^^^^^                                  
 >id : <T>(x: T) => T
diff --git a/tests/baselines/reference/contextualSignatureInstantiation3.types b/tests/baselines/reference/contextualSignatureInstantiation3.types
index f8eb815800496..ed0daa4295e4c 100644
--- a/tests/baselines/reference/contextualSignatureInstantiation3.types
+++ b/tests/baselines/reference/contextualSignatureInstantiation3.types
@@ -15,11 +15,11 @@ function map<T, U>(items: T[], f: (x: T) => U): U[]{
 >items.map(f) : U[]
 >             : ^^^
 >items.map : <U_1>(callbackfn: (value: T, index: number, array: T[]) => U_1, thisArg?: any) => U_1[]
->          : ^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^  
+>          : ^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^
 >items : T[]
 >      : ^^^
 >map : <U_1>(callbackfn: (value: T, index: number, array: T[]) => U_1, thisArg?: any) => U_1[]
->    : ^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^  
+>    : ^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^
 >f : (x: T) => U
 >  : ^ ^^ ^^^^^ 
 }
@@ -71,11 +71,11 @@ var v1 = xs.map(identity);      // Error if not number[]
 >xs.map(identity) : number[]
 >                 : ^^^^^^^^
 >xs.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->       : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>       : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >xs : number[]
 >   : ^^^^^^^^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >identity : <T>(x: T) => T
 >         : ^ ^^ ^^ ^^^^^^
 
@@ -101,11 +101,11 @@ var v2 = xs.map(singleton);     // Error if not number[][]
 >xs.map(singleton) : number[][]
 >                  : ^^^^^^^^^^
 >xs.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->       : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>       : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >xs : number[]
 >   : ^^^^^^^^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >singleton : <T>(x: T) => T[]
 >          : ^ ^^ ^^ ^^^^^^^^
 
diff --git a/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnType.types b/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnType.types
index 78f166f25f0aa..5d8df0c417280 100644
--- a/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnType.types
+++ b/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnType.types
@@ -301,17 +301,17 @@ async function copyExtensions(
 >fromExtensions        .filter((e) => !e.isApplicationScoped)        .map(async (e) => [e, await scanMetadata(e)]) : Promise<[ILocalExtension, Metadata]>[]
 >                                                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >fromExtensions        .filter((e) => !e.isApplicationScoped)        .map : <U>(callbackfn: (value: ILocalExtension, index: number, array: ILocalExtension[]) => U, thisArg?: any) => U[]
->                                                                         : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                                                                         : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >fromExtensions        .filter((e) => !e.isApplicationScoped) : ILocalExtension[]
 >                                                             : ^^^^^^^^^^^^^^^^^
 >fromExtensions        .filter : { <S extends ILocalExtension>(predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => value is S, thisArg?: any): S[]; (predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => unknown, thisArg?: any): ILocalExtension[]; }
->                              : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^  ^^^
+>                              : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >fromExtensions : ILocalExtension[]
 >               : ^^^^^^^^^^^^^^^^^
 
         .filter((e) => !e.isApplicationScoped)
 >filter : { <S extends ILocalExtension>(predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => value is S, thisArg?: any): S[]; (predicate: (value: ILocalExtension, index: number, array: ILocalExtension[]) => unknown, thisArg?: any): ILocalExtension[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >(e) => !e.isApplicationScoped : (e: ILocalExtension) => boolean
 >                              : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >e : ILocalExtension
@@ -327,7 +327,7 @@ async function copyExtensions(
 
         .map(async (e) => [e, await scanMetadata(e)])
 >map : <U>(callbackfn: (value: ILocalExtension, index: number, array: ILocalExtension[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >async (e) => [e, await scanMetadata(e)] : (e: ILocalExtension) => Promise<[ILocalExtension, Metadata]>
 >                                        : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >e : ILocalExtension
diff --git a/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnTypeFromUnion.types b/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnTypeFromUnion.types
index 392a0570d61d8..162ab46ae510a 100644
--- a/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnTypeFromUnion.types
+++ b/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnTypeFromUnion.types
@@ -120,13 +120,13 @@ const cb1: LoadCallback = async () => load().then(m => m);
 >load().then(m => m) : Promise<boolean>
 >                    : ^^^^^^^^^^^^^^^^
 >load().then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->            : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>            : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >load() : Promise<boolean>
 >       : ^^^^^^^^^^^^^^^^
 >load : () => Promise<boolean>
 >     : ^^^^^^                
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >m => m : (m: boolean) => boolean
 >       : ^ ^^^^^^^^^^^^^^^^^^^^^
 >m : boolean
@@ -152,13 +152,13 @@ const cb3: LoadCallback = () => load().then(m => m);
 >load().then(m => m) : Promise<boolean>
 >                    : ^^^^^^^^^^^^^^^^
 >load().then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->            : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>            : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >load() : Promise<boolean>
 >       : ^^^^^^^^^^^^^^^^
 >load : () => Promise<boolean>
 >     : ^^^^^^                
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >m => m : (m: boolean) => boolean
 >       : ^ ^^^^^^^^^^^^^^^^^^^^^
 >m : boolean
diff --git a/tests/baselines/reference/contextuallyTypedIife.types b/tests/baselines/reference/contextuallyTypedIife.types
index 40fd781751832..5333fd7198a1a 100644
--- a/tests/baselines/reference/contextuallyTypedIife.types
+++ b/tests/baselines/reference/contextuallyTypedIife.types
@@ -282,11 +282,11 @@
 >rest.map(n => n > 0) : boolean[]
 >                     : ^^^^^^^^^
 >rest.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->         : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>         : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >rest : [number, number]
 >     : ^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >n => n > 0 : (n: number) => boolean
 >           : ^ ^^^^^^^^^^^^^^^^^^^^
 >n : number
diff --git a/tests/baselines/reference/contextuallyTypedIifeStrict.types b/tests/baselines/reference/contextuallyTypedIifeStrict.types
index d795691332ac2..e19ebb1f8399a 100644
--- a/tests/baselines/reference/contextuallyTypedIifeStrict.types
+++ b/tests/baselines/reference/contextuallyTypedIifeStrict.types
@@ -290,11 +290,11 @@
 >rest.map(n => n > 0) : boolean[]
 >                     : ^^^^^^^^^
 >rest.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->         : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>         : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >rest : [number, number]
 >     : ^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >n => n > 0 : (n: number) => boolean
 >           : ^ ^^^^^^^^^^^^^^^^^^^^
 >n : number
diff --git a/tests/baselines/reference/contravariantInferenceAndTypeGuard.types b/tests/baselines/reference/contravariantInferenceAndTypeGuard.types
index 1466a4c1a8e43..f4d1809ed73b2 100644
--- a/tests/baselines/reference/contravariantInferenceAndTypeGuard.types
+++ b/tests/baselines/reference/contravariantInferenceAndTypeGuard.types
@@ -89,11 +89,11 @@ const filter1 = list2.filter(function(item, node, list): item is Test {
 >list2.filter(function(item, node, list): item is Test {    this.b; // $ExpectType string    item; // $ExpectType Test | null    node; // $ExpectType ListItem<Test | null>    list; // $ExpectType List<Test | null>    return !!item;}, {b: 'c'}) : List<Test>
 >                                                                                                                                                                                                                                                   : ^^^^^^^^^^
 >list2.filter : { <TContext, TResult extends Test | null>(fn: FilterFn<Test | null, TResult, TContext>, context: TContext): List<TResult>; <TResult extends Test | null>(fn: FilterFn<Test | null, TResult, List<Test | null>>): List<TResult>; <TContext>(fn: IteratorFn<Test | null, boolean, TContext>, context: TContext): List<Test | null>; (fn: IteratorFn<Test | null, boolean, List<Test | null>>): List<Test | null>; }
->             : ^^^        ^^       ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^     ^^^^^^^ ^^^       ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^ ^^^        ^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^     ^^^^^^^^^^^ ^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^ ^^^
+>             : ^^^        ^^       ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >list2 : List<Test | null>
 >      : ^^^^^^^^^^^^^^^^^
 >filter : { <TContext, TResult extends Test | null>(fn: FilterFn<Test | null, TResult, TContext>, context: TContext): List<TResult>; <TResult extends Test | null>(fn: FilterFn<Test | null, TResult, List<Test | null>>): List<TResult>; <TContext>(fn: IteratorFn<Test | null, boolean, TContext>, context: TContext): List<Test | null>; (fn: IteratorFn<Test | null, boolean, List<Test | null>>): List<Test | null>; }
->       : ^^^        ^^       ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^     ^^^^^^^ ^^^       ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^ ^^^        ^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^     ^^^^^^^^^^^ ^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^ ^^^
+>       : ^^^        ^^       ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >function(item, node, list): item is Test {    this.b; // $ExpectType string    item; // $ExpectType Test | null    node; // $ExpectType ListItem<Test | null>    list; // $ExpectType List<Test | null>    return !!item;} : (this: { b: string; }, item: Test | null, node: ListItem<Test | null>, list: List<Test | null>) => item is Test
 >                                                                                                                                                                                                                           : ^    ^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^            
 >item : Test | null
diff --git a/tests/baselines/reference/controlFlowDestructuringParameters.types b/tests/baselines/reference/controlFlowDestructuringParameters.types
index 32191a9edc48f..2508969d36c23 100644
--- a/tests/baselines/reference/controlFlowDestructuringParameters.types
+++ b/tests/baselines/reference/controlFlowDestructuringParameters.types
@@ -8,7 +8,7 @@
 >[{ x: 1 }].map(  ({ x }) => x) : number[]
 >                               : ^^^^^^^^
 >[{ x: 1 }].map : <U>(callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any) => U[]
->               : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>               : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[{ x: 1 }] : { x: number; }[]
 >           : ^^^^^^^^^^^^^^^^
 >{ x: 1 } : { x: number; }
@@ -18,7 +18,7 @@
 >1 : 1
 >  : ^
 >map : <U>(callbackfn: (value: { x: number; }, index: number, array: { x: number; }[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 
   ({ x }) => x
 >({ x }) => x : ({ x }: { x: number; }) => number
diff --git a/tests/baselines/reference/controlFlowOuterVariable.types b/tests/baselines/reference/controlFlowOuterVariable.types
index b772a73626f5e..c612b2d60477f 100644
--- a/tests/baselines/reference/controlFlowOuterVariable.types
+++ b/tests/baselines/reference/controlFlowOuterVariable.types
@@ -53,11 +53,11 @@ const helper = function<T>(t: T[]) {
 >t.slice(1) : T[]
 >           : ^^^
 >t.slice : (start?: number, end?: number) => T[]
->        : ^     ^^^      ^^   ^^^      ^^^^^^  
+>        : ^     ^^^      ^^   ^^^      ^^^^^^^^
 >t : T[]
 >  : ^^^
 >slice : (start?: number, end?: number) => T[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^
 >1 : 1
 >  : ^
 }
diff --git a/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types b/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types
index 2994c9c3cf6de..c61879e9f1711 100644
--- a/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types
+++ b/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types
@@ -47,13 +47,13 @@ export let lazyCard = () => import('./Card').then(a => a.default);
 >import('./Card').then(a => a.default) : Promise<(suit: import("Types").Suit, rank: import("Types").Rank) => { suit: import("Types").Suit; rank: import("Types").Rank; }>
 >                                      : ^^^^^^^^^    ^^       ^^^^^^^  ^^^^^^    ^^       ^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >import('./Card').then : <TResult1 = typeof import("Card"), TResult2 = never>(onfulfilled?: (value: typeof import("Card")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                      : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                      : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >import('./Card') : Promise<typeof import("Card")>
 >                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >'./Card' : "./Card"
 >         : ^^^^^^^^
 >then : <TResult1 = typeof import("Card"), TResult2 = never>(onfulfilled?: (value: typeof import("Card")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a => a.default : (a: typeof import("Card")) => (suit: import("Types").Suit, rank: import("Types").Rank) => { suit: import("Types").Suit; rank: import("Types").Rank; }
 >               : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^       ^^^^^^^  ^^^^^^    ^^       ^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a : typeof import("Card")
diff --git a/tests/baselines/reference/declarationEmitHigherOrderRetainedGenerics.types b/tests/baselines/reference/declarationEmitHigherOrderRetainedGenerics.types
index b425a1dafc34a..32975c6fe794a 100644
--- a/tests/baselines/reference/declarationEmitHigherOrderRetainedGenerics.types
+++ b/tests/baselines/reference/declarationEmitHigherOrderRetainedGenerics.types
@@ -337,19 +337,19 @@ export const zipWith = <F extends TypeLambda>(F: SemiApplicative<F>): {
 >F.map(F.product(self, that), ([a, b]) => f(a, b)) : Kind<F, R1 & R2, O1 | O2, E1 | E2, C>
 >                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >F.map : { <A_1, B_1>(f: (a: A_1) => B_1): <R, O, E>(self: Kind<F, R, O, E, A_1>) => Kind<F, R, O, E, B_1>; <R, O, E, A_1, B_1>(self: Kind<F, R, O, E, A_1>, f: (a: A_1) => B_1): Kind<F, R, O, E, B_1>; }
->      : ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^                     ^           ^^^           ^           ^^^ ^^^ ^^ ^^ ^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^     ^  ^  ^  ^  ^^^ ^^^
+>      : ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >F : SemiApplicative<F>
 >  : ^^^^^^^^^^^^^^^^^^
 >map : { <A_1, B_1>(f: (a: A_1) => B_1): <R, O, E>(self: Kind<F, R, O, E, A_1>) => Kind<F, R, O, E, B_1>; <R, O, E, A_1, B_1>(self: Kind<F, R, O, E, A_1>, f: (a: A_1) => B_1): Kind<F, R, O, E, B_1>; }
->    : ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^                     ^           ^^^           ^           ^^^ ^^^ ^^ ^^ ^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^     ^  ^  ^  ^  ^^^ ^^^
+>    : ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >F.product(self, that) : Kind<F, R1 & R2, O1 | O2, E1 | E2, [A, B]>
 >                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >F.product : <R1_1, O1_1, E1_1, A_1, R2_1, O2_1, E2_1, B_1>(self: Kind<F, R1_1, O1_1, E1_1, A_1>, that: Kind<F, R2_1, O2_1, E2_1, B_1>) => Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, [A_1, B_1]>
->          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^  ^^^^   ^^^^  ^^^^   ^^^^  ^^^^   ^^^^   ^^^  ^^^  
+>          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >F : SemiApplicative<F>
 >  : ^^^^^^^^^^^^^^^^^^
 >product : <R1_1, O1_1, E1_1, A_1, R2_1, O2_1, E2_1, B_1>(self: Kind<F, R1_1, O1_1, E1_1, A_1>, that: Kind<F, R2_1, O2_1, E2_1, B_1>) => Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, [A_1, B_1]>
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^  ^^^^   ^^^^  ^^^^   ^^^^  ^^^^   ^^^^   ^^^  ^^^  
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >self : Kind<F, R1, O1, E1, A>
 >     : ^^^^^^^^^^^^^^^^^^^^^^
 >that : Kind<F, R2, O2, E2, B>
@@ -422,7 +422,7 @@ export const zipRight = <F extends TypeLambda>(F: SemiApplicative<F>): {
 >zipWith(F)(self, that, SK) : Kind<F, R1 & R2, O1 | O2, E1 | E2, B>
 >                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zipWith(F) : { <R2_1, O2_1, E2_1, B_1, A, C>(that: Kind<F, R2_1, O2_1, E2_1, B_1>, f: (a: A, b: B_1) => C): <R1_1, O1_1, E1_1>(self: Kind<F, R1_1, O1_1, E1_1, A>) => Kind<F, R1_1 & R2_1, O2_1 | O1_1, E2_1 | E1_1, C>; <R1_1, O1_1, E1_1, A, R2_1, O2_1, E2_1, B_1, C>(self: Kind<F, R1_1, O1_1, E1_1, A>, that: Kind<F, R2_1, O2_1, E2_1, B_1>, f: (a: A, b: B_1) => C): Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, C>; }
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^                              ^                    ^           ^         ^^^^  ^^^^         ^^^^         ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^     ^  ^^^^   ^^^^  ^^^^   ^^^^  ^^^^   ^^^^  ^ ^^^
+>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zipWith : <F extends TypeLambda>(F: SemiApplicative<F>) => { <R2_1, O2_1, E2_1, B_1, A, C>(that: Kind<F, R2_1, O2_1, E2_1, B_1>, f: (a: A, b: B_1) => C): <R1_1, O1_1, E1_1>(self: Kind<F, R1_1, O1_1, E1_1, A>) => Kind<F, R1_1 & R2_1, O2_1 | O1_1, E2_1 | E1_1, C>; <R1_1, O1_2, E1_2, A_1, R2_1, O2_2, E2_2, B_2, C_1>(self: Kind<F, R1_1, O1_2, E1_2, A_1>, that: Kind<F, R2_1, O2_2, E2_2, B_2>, f: (a: A_1, b: B_2) => C_1): Kind<F, R1_1 & R2_1, O1_2 | O2_2, E1_2 | E2_2, C_1>; }
 >        : ^ ^^^^^^^^^          ^^ ^^                  ^^^^^                                                                                                                                                                                                                                                                                                                                                                                                                               
 >F : SemiApplicative<F>
diff --git a/tests/baselines/reference/declarationEmitPromise.types b/tests/baselines/reference/declarationEmitPromise.types
index ae428191b0821..b825f5f18a89b 100644
--- a/tests/baselines/reference/declarationEmitPromise.types
+++ b/tests/baselines/reference/declarationEmitPromise.types
@@ -41,7 +41,7 @@ export async function runSampleWorks<A, B, C, D, E>(
 >[a, b, c, d, e].filter(el => !!el) : bluebird<A>[]
 >                                   : ^^^^^^^^^^^^^
 >[a, b, c, d, e].filter : { <S extends bluebird<A>>(predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => unknown, thisArg?: any): bluebird<A>[]; }
->                       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^  ^^^
+>                       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^
 >[a, b, c, d, e] : bluebird<A>[]
 >                : ^^^^^^^^^^^^^
 >a : bluebird<A>
@@ -55,7 +55,7 @@ export async function runSampleWorks<A, B, C, D, E>(
 >e : bluebird<E>
 >  : ^^^^^^^^^^^
 >filter : { <S extends bluebird<A>>(predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => unknown, thisArg?: any): bluebird<A>[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^
 >el => !!el : (el: bluebird<A>) => boolean
 >           : ^  ^^^^^^^^^^^^^^^^^^^^^^^^^
 >el : bluebird<A>
@@ -141,7 +141,7 @@ export async function runSampleBreaks<A, B, C, D, E>(
 >[a, b, c, d, e].filter(el => !!el) : bluebird<A>[]
 >                                   : ^^^^^^^^^^^^^
 >[a, b, c, d, e].filter : { <S extends bluebird<A>>(predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => unknown, thisArg?: any): bluebird<A>[]; }
->                       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^  ^^^
+>                       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^
 >[a, b, c, d, e] : bluebird<A>[]
 >                : ^^^^^^^^^^^^^
 >a : bluebird<A>
@@ -155,7 +155,7 @@ export async function runSampleBreaks<A, B, C, D, E>(
 >e : bluebird<E>
 >  : ^^^^^^^^^^^
 >filter : { <S extends bluebird<A>>(predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => value is S, thisArg?: any): S[]; (predicate: (value: bluebird<A>, index: number, array: bluebird<A>[]) => unknown, thisArg?: any): bluebird<A>[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^
 >el => !!el : (el: bluebird<A>) => boolean
 >           : ^  ^^^^^^^^^^^^^^^^^^^^^^^^^
 >el : bluebird<A>
diff --git a/tests/baselines/reference/declarationEmitQualifiedAliasTypeArgument.types b/tests/baselines/reference/declarationEmitQualifiedAliasTypeArgument.types
index e451f7933f272..9e6183bdccca3 100644
--- a/tests/baselines/reference/declarationEmitQualifiedAliasTypeArgument.types
+++ b/tests/baselines/reference/declarationEmitQualifiedAliasTypeArgument.types
@@ -56,17 +56,17 @@ import { create } from "./bbb";
 
 export const fun = create<T>();
 >fun : () => import("bbb").INode<T>
->    : ^^^^^^       ^^^^^  ^^^^^ ^ 
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >create<T>() : () => import("bbb").INode<T>
->            : ^^^^^^       ^^^^^  ^^^^^ ^ 
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >create : <T>() => () => import("bbb").INode<T>
 >       : ^ ^^^^^^^             ^^^^^  ^^^^^   
 
 export const fun2 = create<Q>();
 >fun2 : () => import("bbb").INode<Q>
->     : ^^^^^^       ^^^^^  ^^^^^ ^ 
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >create<Q>() : () => import("bbb").INode<Q>
->            : ^^^^^^       ^^^^^  ^^^^^ ^ 
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >create : <T>() => () => import("bbb").INode<T>
 >       : ^ ^^^^^^^             ^^^^^  ^^^^^   
 
diff --git a/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules1.types b/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules1.types
index 5395a0a05aa3a..744dd7c4291a3 100644
--- a/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules1.types
+++ b/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules1.types
@@ -373,12 +373,12 @@ export { UseQueryReturnType, useQuery } from './useQuery-CPqkvEsh.js';
 >UseQueryReturnType : any
 >                   : ^^^
 >useQuery : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").UseQueryReturnType<TData, TError>
->         : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^           ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^               
+>         : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^               
 
 === src/index.mts ===
 import { useQuery } from '@tanstack/vue-query'
 >useQuery : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").UseQueryReturnType<TData, TError>
->         : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^           ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^               
+>         : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^               
 
 const baseUrl = 'https://api.publicapis.org/'
 >baseUrl : "https://api.publicapis.org/"
@@ -431,16 +431,16 @@ const testApi = {
     return fetch(baseUrl + 'entries')
 >fetch(baseUrl + 'entries')      .then((res) => res.json())      .then((data) => data.entries)      .catch((err) => console.log(err)) : Promise<any>
 >                                                                                                                                     : ^^^^^^^^^^^^
->fetch(baseUrl + 'entries')      .then((res) => res.json())      .then((data) => data.entries)      .catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any | TResult>
->                                                                                                          : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^   ^^^^^^^ 
+>fetch(baseUrl + 'entries')      .then((res) => res.json())      .then((data) => data.entries)      .catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>
+>                                                                                                          : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >fetch(baseUrl + 'entries')      .then((res) => res.json())      .then((data) => data.entries) : Promise<any>
 >                                                                                              : ^^^^^^^^^^^^
 >fetch(baseUrl + 'entries')      .then((res) => res.json())      .then : <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->                                                                      : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                                                                      : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >fetch(baseUrl + 'entries')      .then((res) => res.json()) : Promise<any>
 >                                                           : ^^^^^^^^^^^^
 >fetch(baseUrl + 'entries')      .then : <TResult1 = Response, TResult2 = never>(onfulfilled?: ((value: Response) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->                                      : ^        ^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                                      : ^        ^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >fetch(baseUrl + 'entries') : Promise<Response>
 >                           : ^^^^^^^^^^^^^^^^^
 >fetch : (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>
@@ -454,7 +454,7 @@ const testApi = {
 
       .then((res) => res.json())
 >then : <TResult1 = Response, TResult2 = never>(onfulfilled?: ((value: Response) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(res) => res.json() : (res: Response) => Promise<any>
 >                    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >res : Response
@@ -470,7 +470,7 @@ const testApi = {
 
       .then((data) => data.entries)
 >then : <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(data) => data.entries : (data: any) => any
 >                       : ^    ^^^^^^^^^^^^^
 >data : any
@@ -481,8 +481,8 @@ const testApi = {
 >        : ^^^
 
       .catch((err) => console.log(err))
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any | TResult>
->      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^   ^^^^^^^ 
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>
+>      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(err) => console.log(err) : (err: any) => void
 >                          : ^   ^^^^^^^^^^^^^^
 >err : any
@@ -545,7 +545,7 @@ export const useEntries = () => {
 >useQuery({    queryKey: entryKeys.list(),    queryFn: testApi.getEntries,    select: (data) => data.slice(0, 10)  }) : import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").UseQueryReturnType<IEntry[], Error>
 >                                                                                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >useQuery : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").UseQueryReturnType<TData, TError>
->         : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^           ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^               
+>         : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^               
 >{    queryKey: entryKeys.list(),    queryFn: testApi.getEntries,    select: (data) => data.slice(0, 10)  } : { queryKey: readonly ["entries", "list"]; queryFn: () => Promise<IEntry[]>; select: (data: IEntry[]) => IEntry[]; }
 >                                                                                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -581,11 +581,11 @@ export const useEntries = () => {
 >data.slice(0, 10) : IEntry[]
 >                  : ^^^^^^^^
 >data.slice : (start?: number, end?: number) => IEntry[]
->           : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>           : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >data : IEntry[]
 >     : ^^^^^^^^
 >slice : (start?: number, end?: number) => IEntry[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 >10 : 10
diff --git a/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules2.types b/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules2.types
index 0d04a08f5cf1b..2d35ec9aec8c9 100644
--- a/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules2.types
+++ b/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules2.types
@@ -379,14 +379,14 @@ export { b as UseQueryReturnType, u as useQuery } from './useQuery-CPqkvEsh.js';
 >UseQueryReturnType : any
 >                   : ^^^
 >u : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").b<TData, TError>
->  : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^           ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^               
+>  : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^               
 >useQuery : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").b<TData, TError>
->         : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^           ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^               
+>         : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^               
 
 === src/index.mts ===
 import { useQuery } from '@tanstack/vue-query'
 >useQuery : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").b<TData, TError>
->         : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^           ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^               
+>         : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^               
 
 const baseUrl = 'https://api.publicapis.org/'
 >baseUrl : "https://api.publicapis.org/"
@@ -439,16 +439,16 @@ const testApi = {
     return fetch(baseUrl + 'entries')
 >fetch(baseUrl + 'entries')      .then((res) => res.json())      .then((data) => data.entries)      .catch((err) => console.log(err)) : Promise<any>
 >                                                                                                                                     : ^^^^^^^^^^^^
->fetch(baseUrl + 'entries')      .then((res) => res.json())      .then((data) => data.entries)      .catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any | TResult>
->                                                                                                          : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^   ^^^^^^^ 
+>fetch(baseUrl + 'entries')      .then((res) => res.json())      .then((data) => data.entries)      .catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>
+>                                                                                                          : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >fetch(baseUrl + 'entries')      .then((res) => res.json())      .then((data) => data.entries) : Promise<any>
 >                                                                                              : ^^^^^^^^^^^^
 >fetch(baseUrl + 'entries')      .then((res) => res.json())      .then : <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->                                                                      : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                                                                      : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >fetch(baseUrl + 'entries')      .then((res) => res.json()) : Promise<any>
 >                                                           : ^^^^^^^^^^^^
 >fetch(baseUrl + 'entries')      .then : <TResult1 = Response, TResult2 = never>(onfulfilled?: ((value: Response) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->                                      : ^        ^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                                      : ^        ^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >fetch(baseUrl + 'entries') : Promise<Response>
 >                           : ^^^^^^^^^^^^^^^^^
 >fetch : (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>
@@ -462,7 +462,7 @@ const testApi = {
 
       .then((res) => res.json())
 >then : <TResult1 = Response, TResult2 = never>(onfulfilled?: ((value: Response) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(res) => res.json() : (res: Response) => Promise<any>
 >                    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >res : Response
@@ -478,7 +478,7 @@ const testApi = {
 
       .then((data) => data.entries)
 >then : <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(data) => data.entries : (data: any) => any
 >                       : ^    ^^^^^^^^^^^^^
 >data : any
@@ -489,8 +489,8 @@ const testApi = {
 >        : ^^^
 
       .catch((err) => console.log(err))
->catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any | TResult>
->      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^   ^^^^^^^ 
+>catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>
+>      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(err) => console.log(err) : (err: any) => void
 >                          : ^   ^^^^^^^^^^^^^^
 >err : any
@@ -553,7 +553,7 @@ export const useEntries = () => {
 >useQuery({    queryKey: entryKeys.list(),    queryFn: testApi.getEntries,    select: (data) => data.slice(0, 10)  }) : import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").b<IEntry[], Error>
 >                                                                                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >useQuery : <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: { enabled?: boolean; refetchInterval?: number; select?: ((data: TQueryFnData) => TData) | undefined; retry?: (number | boolean | ((failureCount: number, error: TError) => boolean)) | undefined; queryFn?: ((context: { queryKey: TQueryKey; }) => TQueryFnData | Promise<TQueryFnData>) | undefined; queryKey?: TQueryKey | undefined; initialData?: TQueryFnData | undefined; initialDataUpdatedAt?: number | (() => number | undefined); } & { initialData?: undefined; }) => import("node_modules/@tanstack/vue-query/build/modern/useQuery-CPqkvEsh").b<TData, TError>
->         : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^           ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^               
+>         : ^            ^^^^^^^^^^^^      ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                   ^^^^^^^^^^^^^^^^^^^^^^         ^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^               
 >{    queryKey: entryKeys.list(),    queryFn: testApi.getEntries,    select: (data) => data.slice(0, 10)  } : { queryKey: readonly ["entries", "list"]; queryFn: () => Promise<IEntry[]>; select: (data: IEntry[]) => IEntry[]; }
 >                                                                                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -589,11 +589,11 @@ export const useEntries = () => {
 >data.slice(0, 10) : IEntry[]
 >                  : ^^^^^^^^
 >data.slice : (start?: number, end?: number) => IEntry[]
->           : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>           : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >data : IEntry[]
 >     : ^^^^^^^^
 >slice : (start?: number, end?: number) => IEntry[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 >10 : 10
diff --git a/tests/baselines/reference/declarationEmitUsingTypeAlias2.types b/tests/baselines/reference/declarationEmitUsingTypeAlias2.types
index fec54d38ef751..a64aa378cc928 100644
--- a/tests/baselines/reference/declarationEmitUsingTypeAlias2.types
+++ b/tests/baselines/reference/declarationEmitUsingTypeAlias2.types
@@ -105,10 +105,10 @@ import { goodDeclaration, shouldReuseLocalName, shouldBeElided } from "some-dep"
 >               : ^^^^^^^^^^^^^
 
 export const bar = goodDeclaration<{}>;
->bar : () => () => { shouldPrintResult: {} extends import("node_modules/some-dep/dist/inner").Other ? "O" : "N"; shouldPrintResult2: {} extends typeof shouldBeElided ? import("node_modules/some-dep/dist/inner").Other : "N"; shouldLookupName: typeof import("node_modules/some-dep/dist/other").shouldLookupName; shouldReuseLocalName: typeof shouldReuseLocalName; reuseDepName: typeof import("node_modules/some-dep/dist/other").reuseDepName; }
->    : ^^^^^^                           ^^                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^                                  ^^                ^^^^^^^^^^^^^^          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^                                                                                                                           ^^^^^^^^^^^^^^^^^^^^                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^   
->goodDeclaration<{}> : () => () => { shouldPrintResult: {} extends import("node_modules/some-dep/dist/inner").Other ? "O" : "N"; shouldPrintResult2: {} extends typeof shouldBeElided ? import("node_modules/some-dep/dist/inner").Other : "N"; shouldLookupName: typeof import("node_modules/some-dep/dist/other").shouldLookupName; shouldReuseLocalName: typeof shouldReuseLocalName; reuseDepName: typeof import("node_modules/some-dep/dist/other").reuseDepName; }
->                    : ^^^^^^                           ^^                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^                                  ^^                ^^^^^^^^^^^^^^          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^                                                                                                                           ^^^^^^^^^^^^^^^^^^^^                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^   
+>bar : () => () => { shouldPrintResult: "N"; shouldPrintResult2: "N"; shouldLookupName: typeof import("node_modules/some-dep/dist/other").shouldLookupName; shouldReuseLocalName: typeof shouldReuseLocalName; reuseDepName: typeof import("node_modules/some-dep/dist/other").reuseDepName; }
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                                                  ^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^
+>goodDeclaration<{}> : () => () => { shouldPrintResult: "N"; shouldPrintResult2: "N"; shouldLookupName: typeof import("node_modules/some-dep/dist/other").shouldLookupName; shouldReuseLocalName: typeof shouldReuseLocalName; reuseDepName: typeof import("node_modules/some-dep/dist/other").reuseDepName; }
+>                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                                                  ^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^
 >goodDeclaration : <T>() => () => { shouldPrintResult: T extends import("node_modules/some-dep/dist/inner").Other ? "O" : "N"; shouldPrintResult2: T extends typeof shouldBeElided ? import("node_modules/some-dep/dist/inner").Other : "N"; shouldLookupName: typeof import("node_modules/some-dep/dist/other").shouldLookupName; shouldReuseLocalName: typeof shouldReuseLocalName; reuseDepName: typeof import("node_modules/some-dep/dist/other").reuseDepName; }
 >                : ^ ^^^^^^^                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^                                                   ^^^^^^^^^^^^^^          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^                                                                                                                           ^^^^^^^^^^^^^^^^^^^^                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^   
 
diff --git a/tests/baselines/reference/dependentDestructuredVariables.types b/tests/baselines/reference/dependentDestructuredVariables.types
index 9a069c813ee3f..52e4690a91f2b 100644
--- a/tests/baselines/reference/dependentDestructuredVariables.types
+++ b/tests/baselines/reference/dependentDestructuredVariables.types
@@ -800,11 +800,11 @@ const { value, done } = it.next();
 >it.next() : IteratorResult<number, any>
 >          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >it.next : (...args: [] | [undefined]) => IteratorResult<number, any>
->        : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^  ^^^ 
+>        : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >it : Iterator<number, any, undefined>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >next : (...args: [] | [undefined]) => IteratorResult<number, any>
->     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^  ^^^ 
+>     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 if (!done) {
 >!done : boolean
@@ -1086,7 +1086,7 @@ const reducer: (...args: ReducerArgs) => void = (op, args) => {
 >args.firstArr.concat(args.secondArr) : any[]
 >                                     : ^^^^^
 >args.firstArr.concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
->                     : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^  ^^^
+>                     : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^
 >args.firstArr : any[]
 >              : ^^^^^
 >args : { firstArr: any[]; secondArr: any[]; }
@@ -1094,7 +1094,7 @@ const reducer: (...args: ReducerArgs) => void = (op, args) => {
 >firstArr : any[]
 >         : ^^^^^
 >concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^
 >args.secondArr : any[]
 >               : ^^^^^
 >args : { firstArr: any[]; secondArr: any[]; }
diff --git a/tests/baselines/reference/dependentDestructuredVariablesFromNestedPatterns.types b/tests/baselines/reference/dependentDestructuredVariablesFromNestedPatterns.types
index 4d3daef7b8747..f3e90d08edc7f 100644
--- a/tests/baselines/reference/dependentDestructuredVariablesFromNestedPatterns.types
+++ b/tests/baselines/reference/dependentDestructuredVariablesFromNestedPatterns.types
@@ -77,11 +77,11 @@ async function myAllSettled<T extends readonly unknown[]>(fn: () => T) {
 >promises.map((result) =>    result.status === "fulfilled"      ? [result.value, undefined]      : [undefined, new Error(String(result.reason))],  ) : ([undefined, Error] | [unknown, undefined])[]
 >                                                                                                                                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >promises.map : <U>(callbackfn: (value: PromiseSettledResult<unknown>, index: number, array: PromiseSettledResult<unknown>[]) => U, thisArg?: any) => U[]
->             : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>             : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >promises : { -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }
 >         : ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: PromiseSettledResult<unknown>, index: number, array: PromiseSettledResult<unknown>[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(result) =>    result.status === "fulfilled"      ? [result.value, undefined]      : [undefined, new Error(String(result.reason))] : (result: PromiseSettledResult<unknown>) => [undefined, Error] | [unknown, undefined]
 >                                                                                                                                   : ^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >result : PromiseSettledResult<unknown>
diff --git a/tests/baselines/reference/destructureOfVariableSameAsShorthand.types b/tests/baselines/reference/destructureOfVariableSameAsShorthand.types
index ca91a2cbb1630..e29e0a383563c 100644
--- a/tests/baselines/reference/destructureOfVariableSameAsShorthand.types
+++ b/tests/baselines/reference/destructureOfVariableSameAsShorthand.types
@@ -21,13 +21,13 @@ async function main() {
 >get().then((response) => {        // body is never        const body = response.data;    }) : Promise<void>
 >                                                                                            : ^^^^^^^^^^^^^
 >get().then : <TResult1 = AxiosResponse<never>, TResult2 = never>(onfulfilled?: (value: AxiosResponse<never>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->           : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>           : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >get() : Promise<AxiosResponse<never>>
 >      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >get : <T = never, R = AxiosResponse<T>>() => Promise<R>
 >    : ^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^          
 >then : <TResult1 = AxiosResponse<never>, TResult2 = never>(onfulfilled?: (value: AxiosResponse<never>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(response) => {        // body is never        const body = response.data;    } : (response: AxiosResponse<never>) => void
 >                                                                                : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >response : AxiosResponse<never>
@@ -49,13 +49,13 @@ async function main() {
 >get().then(({ data }) => {        // data is never    }) : Promise<void>
 >                                                         : ^^^^^^^^^^^^^
 >get().then : <TResult1 = AxiosResponse<never>, TResult2 = never>(onfulfilled?: (value: AxiosResponse<never>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->           : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>           : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >get() : Promise<AxiosResponse<never>>
 >      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >get : <T = never, R = AxiosResponse<T>>() => Promise<R>
 >    : ^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^          
 >then : <TResult1 = AxiosResponse<never>, TResult2 = never>(onfulfilled?: (value: AxiosResponse<never>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >({ data }) => {        // data is never    } : ({ data }: AxiosResponse<never>) => void
 >                                             : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >data : never
diff --git a/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.types b/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.types
index a72bf873fb4ca..9c15d6b2b210d 100644
--- a/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.types
+++ b/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.types
@@ -9,7 +9,7 @@ let { [Symbol.iterator]: destructured } = [];
 >iterator : unique symbol
 >         : ^^^^^^^^^^^^^
 >destructured : () => IterableIterator<undefined>
->             : ^^^^^^                 ^^^^^^^^^ 
+>             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 
@@ -17,7 +17,7 @@ void destructured;
 >void destructured : undefined
 >                  : ^^^^^^^^^
 >destructured : () => IterableIterator<undefined>
->             : ^^^^^^                 ^^^^^^^^^ 
+>             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const named = "prop";
 >named : "prop"
diff --git a/tests/baselines/reference/destructuringAssignmentWithDefault2.types b/tests/baselines/reference/destructuringAssignmentWithDefault2.types
index 9f76ce73a3f75..864ec12dff585 100644
--- a/tests/baselines/reference/destructuringAssignmentWithDefault2.types
+++ b/tests/baselines/reference/destructuringAssignmentWithDefault2.types
@@ -174,11 +174,11 @@ let value;
 >r.next() : IteratorResult<number, any>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r.next : (...args: [] | [undefined]) => IteratorResult<number, any>
->       : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^  ^^^ 
+>       : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r : Iterator<number, any, undefined>
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >next : (...args: [] | [undefined]) => IteratorResult<number, any>
->     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^  ^^^ 
+>     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 ({ done: done = false, value } = r.next());
 >({ done: done = false, value } = r.next()) : IteratorResult<number, any>
@@ -200,9 +200,9 @@ let value;
 >r.next() : IteratorResult<number, any>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r.next : (...args: [] | [undefined]) => IteratorResult<number, any>
->       : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^  ^^^ 
+>       : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r : Iterator<number, any, undefined>
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >next : (...args: [] | [undefined]) => IteratorResult<number, any>
->     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^  ^^^ 
+>     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/destructuringTuple.types b/tests/baselines/reference/destructuringTuple.types
index cfb3d1c32174d..fb6010eb4adb1 100644
--- a/tests/baselines/reference/destructuringTuple.types
+++ b/tests/baselines/reference/destructuringTuple.types
@@ -63,11 +63,11 @@ const [oops1] = [1, 2, 3].reduce((accu, el) => accu.concat(el), []);
 >accu.concat(el) : never[]
 >                : ^^^^^^^
 >accu.concat : { (...items: ConcatArray<never>[]): never[]; (...items: ConcatArray<never>[]): never[]; }
->            : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>            : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >accu : []
 >     : ^^
 >concat : { (...items: ConcatArray<never>[]): never[]; (...items: ConcatArray<never>[]): never[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >el : number
 >   : ^^^^^^
 >[] : never[]
@@ -99,11 +99,11 @@ const [oops2] = [1, 2, 3].reduce((acc: number[], e) => acc.concat(e), []);
 >acc.concat(e) : number[]
 >              : ^^^^^^^^
 >acc.concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
->           : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>           : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >acc : number[]
 >    : ^^^^^^^^
 >concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >e : number
 >  : ^^^^^^
 >[] : never[]
diff --git a/tests/baselines/reference/discriminantsAndPrimitives.types b/tests/baselines/reference/discriminantsAndPrimitives.types
index b938772b2c63e..b432b6137e72f 100644
--- a/tests/baselines/reference/discriminantsAndPrimitives.types
+++ b/tests/baselines/reference/discriminantsAndPrimitives.types
@@ -260,7 +260,7 @@ if (n.type === "Disjunction") {
 >n.alternatives.slice() : string[]
 >                       : ^^^^^^^^
 >n.alternatives.slice : (start?: number, end?: number) => string[]
->                     : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>                     : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >n.alternatives : string[]
 >               : ^^^^^^^^
 >n : Disjunction
@@ -268,14 +268,14 @@ if (n.type === "Disjunction") {
 >alternatives : string[]
 >             : ^^^^^^^^
 >slice : (start?: number, end?: number) => string[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 }
 else {
     n.elements.slice() // n should be narrowed to Pattern
 >n.elements.slice() : string[]
 >                   : ^^^^^^^^
 >n.elements.slice : (start?: number, end?: number) => string[]
->                 : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>                 : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >n.elements : string[]
 >           : ^^^^^^^^
 >n : Pattern
@@ -283,6 +283,6 @@ else {
 >elements : string[]
 >         : ^^^^^^^^
 >slice : (start?: number, end?: number) => string[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 }
 
diff --git a/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=false).types b/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=false).types
index ad5ff3c9b6638..b6b348657dfee 100644
--- a/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=false).types
+++ b/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=false).types
@@ -27,8 +27,8 @@ function mapAsyncIterable<T, U, R = undefined>(
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterable[Symbol.asyncIterator]() : AsyncIterator<T, any, undefined>
 >                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iterable[Symbol.asyncIterator] : (() => AsyncGenerator<T, R, void>) | (() => AsyncIterator<T>)
->                               : ^^^^^^^               ^  ^  ^^^^ ^^^^^^^^^^^              ^ ^
+>iterable[Symbol.asyncIterator] : (() => AsyncGenerator<T, R, void>) | (() => AsyncIterator<T, any, undefined>)
+>                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterable : AsyncGenerator<T, R, void> | AsyncIterable<T>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Symbol.asyncIterator : unique symbol
@@ -93,11 +93,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >typeof iterator.return : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
 >                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
->                : ^^     ^^^^^^^^^^^                       ^  ^^^  ^^^^^^^^^^^^^
+>                : ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
->       : ^^     ^^^^^^^^^^^                       ^  ^^^  ^^^^^^^^^^^^^
+>       : ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >"function" : "function"
 >           : ^^^^^^^^^^
 
@@ -108,11 +108,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >iterator.return() : Promise<IteratorResult<T, any>>
 >                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.return : (value?: any) => Promise<IteratorResult<T, any>>
->                : ^     ^^^^^^^^^^^                       ^  ^^^  
+>                : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >return : (value?: any) => Promise<IteratorResult<T, any>>
->       : ^     ^^^^^^^^^^^                       ^  ^^^  
+>       : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         } catch (_e) {}
 >_e : unknown
@@ -142,11 +142,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >iterator.next() : Promise<IteratorResult<T, any>>
 >                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.next : (...args: [] | [undefined]) => Promise<IteratorResult<T, any>>
->              : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^                       ^  ^^^  
+>              : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >next : (...args: [] | [undefined]) => Promise<IteratorResult<T, any>>
->     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^                       ^  ^^^  
+>     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     },
     async return(): Promise<IteratorResult<U, R>> {
@@ -161,11 +161,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >typeof iterator.return : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
 >                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
->                : ^^     ^^^^^^^^^^^                       ^  ^^^  ^^^^^^^^^^^^^
+>                : ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
->       : ^^     ^^^^^^^^^^^                       ^  ^^^  ^^^^^^^^^^^^^
+>       : ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >"function" : "function"
 >           : ^^^^^^^^^^
 
@@ -179,11 +179,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >iterator.return() : Promise<IteratorResult<T, any>>
 >                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.return : (value?: any) => Promise<IteratorResult<T, any>>
->                : ^     ^^^^^^^^^^^                       ^  ^^^  
+>                : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >return : (value?: any) => Promise<IteratorResult<T, any>>
->       : ^     ^^^^^^^^^^^                       ^  ^^^  
+>       : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         : { value: undefined as any, done: true };
 >{ value: undefined as any, done: true } : { value: any; done: true; }
@@ -210,11 +210,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >typeof iterator.throw : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
 >                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.throw : ((e?: any) => Promise<IteratorResult<T, any>>) | undefined
->               : ^^ ^^^   ^^^^^                       ^  ^^^  ^^^^^^^^^^^^^
+>               : ^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >throw : ((e?: any) => Promise<IteratorResult<T, any>>) | undefined
->      : ^^ ^^^   ^^^^^                       ^  ^^^  ^^^^^^^^^^^^^
+>      : ^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >"function" : "function"
 >           : ^^^^^^^^^^
 
@@ -228,11 +228,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >iterator.throw(error) : Promise<IteratorResult<T, any>>
 >                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.throw : (e?: any) => Promise<IteratorResult<T, any>>
->               : ^ ^^^   ^^^^^                       ^  ^^^  
+>               : ^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >throw : (e?: any) => Promise<IteratorResult<T, any>>
->      : ^ ^^^   ^^^^^                       ^  ^^^  
+>      : ^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >error : unknown
 >      : ^^^^^^^
       }
@@ -310,11 +310,11 @@ const iterable = {
 >items.shift() : number | undefined
 >              : ^^^^^^^^^^^^^^^^^^
 >items.shift : () => number | undefined
->            : ^^^^^^^^^^^^            
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^
 >items : number[]
 >      : ^^^^^^^^
 >shift : () => number | undefined
->      : ^^^^^^^^^^^^            
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^
 
     return Promise.resolve({
 >Promise.resolve({      done: items.length === 0,      value,    }) : Promise<{ done: boolean; value: number; }>
diff --git a/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=true).types b/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=true).types
index ad5ff3c9b6638..b6b348657dfee 100644
--- a/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=true).types
+++ b/tests/baselines/reference/discriminateWithOptionalProperty2(exactoptionalpropertytypes=true).types
@@ -27,8 +27,8 @@ function mapAsyncIterable<T, U, R = undefined>(
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterable[Symbol.asyncIterator]() : AsyncIterator<T, any, undefined>
 >                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iterable[Symbol.asyncIterator] : (() => AsyncGenerator<T, R, void>) | (() => AsyncIterator<T>)
->                               : ^^^^^^^               ^  ^  ^^^^ ^^^^^^^^^^^              ^ ^
+>iterable[Symbol.asyncIterator] : (() => AsyncGenerator<T, R, void>) | (() => AsyncIterator<T, any, undefined>)
+>                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterable : AsyncGenerator<T, R, void> | AsyncIterable<T>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Symbol.asyncIterator : unique symbol
@@ -93,11 +93,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >typeof iterator.return : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
 >                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
->                : ^^     ^^^^^^^^^^^                       ^  ^^^  ^^^^^^^^^^^^^
+>                : ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
->       : ^^     ^^^^^^^^^^^                       ^  ^^^  ^^^^^^^^^^^^^
+>       : ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >"function" : "function"
 >           : ^^^^^^^^^^
 
@@ -108,11 +108,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >iterator.return() : Promise<IteratorResult<T, any>>
 >                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.return : (value?: any) => Promise<IteratorResult<T, any>>
->                : ^     ^^^^^^^^^^^                       ^  ^^^  
+>                : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >return : (value?: any) => Promise<IteratorResult<T, any>>
->       : ^     ^^^^^^^^^^^                       ^  ^^^  
+>       : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         } catch (_e) {}
 >_e : unknown
@@ -142,11 +142,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >iterator.next() : Promise<IteratorResult<T, any>>
 >                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.next : (...args: [] | [undefined]) => Promise<IteratorResult<T, any>>
->              : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^                       ^  ^^^  
+>              : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >next : (...args: [] | [undefined]) => Promise<IteratorResult<T, any>>
->     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^                       ^  ^^^  
+>     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     },
     async return(): Promise<IteratorResult<U, R>> {
@@ -161,11 +161,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >typeof iterator.return : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
 >                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
->                : ^^     ^^^^^^^^^^^                       ^  ^^^  ^^^^^^^^^^^^^
+>                : ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >return : ((value?: any) => Promise<IteratorResult<T, any>>) | undefined
->       : ^^     ^^^^^^^^^^^                       ^  ^^^  ^^^^^^^^^^^^^
+>       : ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >"function" : "function"
 >           : ^^^^^^^^^^
 
@@ -179,11 +179,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >iterator.return() : Promise<IteratorResult<T, any>>
 >                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.return : (value?: any) => Promise<IteratorResult<T, any>>
->                : ^     ^^^^^^^^^^^                       ^  ^^^  
+>                : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >return : (value?: any) => Promise<IteratorResult<T, any>>
->       : ^     ^^^^^^^^^^^                       ^  ^^^  
+>       : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         : { value: undefined as any, done: true };
 >{ value: undefined as any, done: true } : { value: any; done: true; }
@@ -210,11 +210,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >typeof iterator.throw : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
 >                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.throw : ((e?: any) => Promise<IteratorResult<T, any>>) | undefined
->               : ^^ ^^^   ^^^^^                       ^  ^^^  ^^^^^^^^^^^^^
+>               : ^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >throw : ((e?: any) => Promise<IteratorResult<T, any>>) | undefined
->      : ^^ ^^^   ^^^^^                       ^  ^^^  ^^^^^^^^^^^^^
+>      : ^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >"function" : "function"
 >           : ^^^^^^^^^^
 
@@ -228,11 +228,11 @@ function mapAsyncIterable<T, U, R = undefined>(
 >iterator.throw(error) : Promise<IteratorResult<T, any>>
 >                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator.throw : (e?: any) => Promise<IteratorResult<T, any>>
->               : ^ ^^^   ^^^^^                       ^  ^^^  
+>               : ^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >iterator : AsyncIterator<T, any, undefined>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >throw : (e?: any) => Promise<IteratorResult<T, any>>
->      : ^ ^^^   ^^^^^                       ^  ^^^  
+>      : ^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >error : unknown
 >      : ^^^^^^^
       }
@@ -310,11 +310,11 @@ const iterable = {
 >items.shift() : number | undefined
 >              : ^^^^^^^^^^^^^^^^^^
 >items.shift : () => number | undefined
->            : ^^^^^^^^^^^^            
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^
 >items : number[]
 >      : ^^^^^^^^
 >shift : () => number | undefined
->      : ^^^^^^^^^^^^            
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^
 
     return Promise.resolve({
 >Promise.resolve({      done: items.length === 0,      value,    }) : Promise<{ done: boolean; value: number; }>
diff --git a/tests/baselines/reference/dissallowSymbolAsWeakType.types b/tests/baselines/reference/dissallowSymbolAsWeakType.types
index a59a4c871eda4..b5728d2b592e7 100644
--- a/tests/baselines/reference/dissallowSymbolAsWeakType.types
+++ b/tests/baselines/reference/dissallowSymbolAsWeakType.types
@@ -104,12 +104,12 @@ wm.has(s);
 wm.get(s);
 >wm.get(s) : boolean
 >          : ^^^^^^^
->wm.get : (key: object) => boolean | undefined
->       : ^   ^^^^^^^^^^^^^^^^^^^^            
+>wm.get : (key: object) => boolean
+>       : ^   ^^^^^^^^^^^^^^^^^^^^
 >wm : WeakMap<object, boolean>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^
->get : (key: object) => boolean | undefined
->    : ^   ^^^^^^^^^^^^^^^^^^^^            
+>get : (key: object) => boolean
+>    : ^   ^^^^^^^^^^^^^^^^^^^^
 >s : symbol
 >  : ^^^^^^
 
@@ -138,12 +138,12 @@ const wr = new WeakRef(s);
 wr.deref();
 >wr.deref() : object
 >           : ^^^^^^
->wr.deref : () => object | undefined
->         : ^^^^^^^^^^^^            
+>wr.deref : () => object
+>         : ^^^^^^^^^^^^
 >wr : WeakRef<object>
 >   : ^^^^^^^^^^^^^^^
->deref : () => object | undefined
->      : ^^^^^^^^^^^^            
+>deref : () => object
+>      : ^^^^^^^^^^^^
 
 const f = new FinalizationRegistry(() => {});
 >f : FinalizationRegistry<unknown>
diff --git a/tests/baselines/reference/doYouNeedToChangeYourTargetLibraryES2023(target=esnext).types b/tests/baselines/reference/doYouNeedToChangeYourTargetLibraryES2023(target=esnext).types
index 17c492bd36cbf..90d3ec6d7ae9f 100644
--- a/tests/baselines/reference/doYouNeedToChangeYourTargetLibraryES2023(target=esnext).types
+++ b/tests/baselines/reference/doYouNeedToChangeYourTargetLibraryES2023(target=esnext).types
@@ -72,11 +72,11 @@ export let last1 = array.findLast(somePredicate);
 >array.findLast(somePredicate) : number | undefined
 >                              : ^^^^^^^^^^^^^^^^^^
 >array.findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number | undefined; }
->               : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>               : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
 >findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number | undefined; }
->         : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>         : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^
 >somePredicate : (x: any) => boolean
 >              : ^ ^^   ^^^^^       
 
@@ -86,11 +86,11 @@ export let last2 = array.findLast(somePredicate);
 >array.findLast(somePredicate) : number | undefined
 >                              : ^^^^^^^^^^^^^^^^^^
 >array.findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number | undefined; }
->               : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>               : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
 >findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number | undefined; }
->         : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>         : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^
 >somePredicate : (x: any) => boolean
 >              : ^ ^^   ^^^^^       
 
@@ -100,11 +100,11 @@ export let sorted = array.toSorted();
 >array.toSorted() : number[]
 >                 : ^^^^^^^^
 >array.toSorted : (compareFn?: ((a: number, b: number) => number) | undefined) => number[]
->               : ^         ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^  
+>               : ^         ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
 >toSorted : (compareFn?: ((a: number, b: number) => number) | undefined) => number[]
->         : ^         ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^  
+>         : ^         ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 export let spliced1 = array.toSpliced(2);
 >spliced1 : number[]
@@ -112,11 +112,11 @@ export let spliced1 = array.toSpliced(2);
 >array.toSpliced(2) : number[]
 >                   : ^^^^^^^^
 >array.toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
->                : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^
+>                : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
 >toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
->          : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^
+>          : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^
 >2 : 2
 >  : ^
 
@@ -126,11 +126,11 @@ export let spliced2 = array.toSpliced(2, 1);
 >array.toSpliced(2, 1) : number[]
 >                      : ^^^^^^^^
 >array.toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
->                : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^
+>                : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
 >toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
->          : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^
+>          : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^
 >2 : 2
 >  : ^
 >1 : 1
@@ -142,11 +142,11 @@ export let spliced3 = array.toSpliced(2, 1, 4, 5, 6, 7);
 >array.toSpliced(2, 1, 4, 5, 6, 7) : number[]
 >                                  : ^^^^^^^^
 >array.toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
->                : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^
+>                : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
 >toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
->          : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^
+>          : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^
 >2 : 2
 >  : ^
 >1 : 1
@@ -166,11 +166,11 @@ export let spliced4 = array.toSpliced(2, undefined);
 >array.toSpliced(2, undefined) : number[]
 >                              : ^^^^^^^^
 >array.toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
->                : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^
+>                : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
 >toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
->          : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^
+>          : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^
 >2 : 2
 >  : ^
 >undefined : undefined
@@ -182,11 +182,11 @@ export let spliced5 = array.toSpliced(2, undefined, 4, 5, 6, 7);
 >array.toSpliced(2, undefined, 4, 5, 6, 7) : number[]
 >                                          : ^^^^^^^^
 >array.toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
->                : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^
+>                : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
 >toSpliced : { (start: number, deleteCount: number, ...items: number[]): number[]; (start: number, deleteCount?: number): number[]; }
->          : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^
+>          : ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^
 >2 : 2
 >  : ^
 >undefined : undefined
@@ -206,11 +206,11 @@ export let startsWithOne = array.with(0, 1);
 >array.with(0, 1) : number[]
 >                 : ^^^^^^^^
 >array.with : (index: number, value: number) => number[]
->           : ^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^  
+>           : ^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
 >with : (index: number, value: number) => number[]
->     : ^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^  
+>     : ^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 >1 : 1
@@ -222,11 +222,11 @@ export let inTheEnd = array.with(-1, 1);
 >array.with(-1, 1) : number[]
 >                  : ^^^^^^^^
 >array.with : (index: number, value: number) => number[]
->           : ^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^  
+>           : ^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
 >with : (index: number, value: number) => number[]
->     : ^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^  
+>     : ^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^
 >-1 : -1
 >   : ^^
 >1 : 1
diff --git a/tests/baselines/reference/emitSkipsThisWithRestParameter.types b/tests/baselines/reference/emitSkipsThisWithRestParameter.types
index 828c1175c3aac..36d12ca85aa00 100644
--- a/tests/baselines/reference/emitSkipsThisWithRestParameter.types
+++ b/tests/baselines/reference/emitSkipsThisWithRestParameter.types
@@ -31,12 +31,12 @@ function rebase(fn: (base: any, ...args: any[]) => any): (...args: any[]) => any
 >[ this ].concat(args) : any[]
 >                      : ^^^^^
 >[ this ].concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
->                : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^  ^^^
+>                : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^
 >[ this ] : any[]
 >         : ^^^^^
 >this : any
 >concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^
 >args : any[]
 >     : ^^^^^
 
diff --git a/tests/baselines/reference/emptyArrayDestructuringExpressionVisitedByTransformer.types b/tests/baselines/reference/emptyArrayDestructuringExpressionVisitedByTransformer.types
index 482c34286bbf2..8d68b05c24f81 100644
--- a/tests/baselines/reference/emptyArrayDestructuringExpressionVisitedByTransformer.types
+++ b/tests/baselines/reference/emptyArrayDestructuringExpressionVisitedByTransformer.types
@@ -11,13 +11,13 @@ var a = [] = [1].map(_ => _);
 >[1].map(_ => _) : number[]
 >                : ^^^^^^^^
 >[1].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->        : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>        : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1] : number[]
 >    : ^^^^^^^^
 >1 : 1
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >_ => _ : (_: number) => number
 >       : ^ ^^^^^^^^^^^^^^^^^^^
 >_ : number
@@ -31,13 +31,13 @@ var b = [1].map(_ => _);
 >[1].map(_ => _) : number[]
 >                : ^^^^^^^^
 >[1].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->        : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>        : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1] : number[]
 >    : ^^^^^^^^
 >1 : 1
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >_ => _ : (_: number) => number
 >       : ^ ^^^^^^^^^^^^^^^^^^^
 >_ : number
diff --git a/tests/baselines/reference/enumIndexer.types b/tests/baselines/reference/enumIndexer.types
index 897379f260ead..0939ffb04c540 100644
--- a/tests/baselines/reference/enumIndexer.types
+++ b/tests/baselines/reference/enumIndexer.types
@@ -45,11 +45,11 @@ var x = _arr.map(o => MyEnumType[o.key] === enumValue); // these are not same ty
 >_arr.map(o => MyEnumType[o.key] === enumValue) : boolean[]
 >                                               : ^^^^^^^^^
 >_arr.map : <U>(callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any) => U[]
->         : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>         : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >_arr : { key: string; }[]
 >     : ^^^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: { key: string; }, index: number, array: { key: string; }[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >o => MyEnumType[o.key] === enumValue : (o: { key: string; }) => boolean
 >                                     : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >o : { key: string; }
diff --git a/tests/baselines/reference/es2018ObjectAssign.types b/tests/baselines/reference/es2018ObjectAssign.types
index 3ae8df0b5c585..6740751216557 100644
--- a/tests/baselines/reference/es2018ObjectAssign.types
+++ b/tests/baselines/reference/es2018ObjectAssign.types
@@ -29,9 +29,9 @@ p.finally();
 >p.finally() : Promise<number>
 >            : ^^^^^^^^^^^^^^^
 >p.finally : (onfinally?: () => void) => Promise<number>
->          : ^         ^^^^^^^^^    ^^^^^        ^^^^^^ 
+>          : ^         ^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^
 >p : Promise<number>
 >  : ^^^^^^^^^^^^^^^
 >finally : (onfinally?: () => void) => Promise<number>
->        : ^         ^^^^^^^^^    ^^^^^        ^^^^^^ 
+>        : ^         ^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/esDecorators-contextualTypes.2.types b/tests/baselines/reference/esDecorators-contextualTypes.2.types
index 6edb24a32891d..8e662b83fdc46 100644
--- a/tests/baselines/reference/esDecorators-contextualTypes.2.types
+++ b/tests/baselines/reference/esDecorators-contextualTypes.2.types
@@ -6,8 +6,8 @@ class C {
 >  : ^
 
     @boundMethodLogger("Yadda", /*bound*/ true)
->boundMethodLogger("Yadda", /*bound*/ true) : (target: (this: C) => void, context: ClassMethodDecoratorContext<C, (this: C) => void>) => ((this: C, ...args: []) => void)
->                                           : ^      ^^^    ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^        ^           ^^     ^^^^ 
+>boundMethodLogger("Yadda", /*bound*/ true) : (target: (this: C) => void, context: ClassMethodDecoratorContext<C, (this: C) => void>) => (this: C) => void
+>                                           : ^      ^^^    ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^
 >boundMethodLogger : <This, Args extends any[], Return>(source: string, bound?: boolean) => (target: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => ((this: This, ...args: Args) => Return)
 >                  : ^    ^^    ^^^^^^^^^     ^^      ^^      ^^      ^^     ^^^^^^^^^^^^^^^^      ^^                                     ^^       ^^                                                                        ^^^^^                                       
 >"Yadda" : "Yadda"
diff --git a/tests/baselines/reference/esModuleInteropImportCall.types b/tests/baselines/reference/esModuleInteropImportCall.types
index e362179346221..eaf2af09696e6 100644
--- a/tests/baselines/reference/esModuleInteropImportCall.types
+++ b/tests/baselines/reference/esModuleInteropImportCall.types
@@ -15,13 +15,13 @@ import("./foo").then(f => {
 >import("./foo").then(f => {    f.default;}) : Promise<void>
 >                                            : ^^^^^^^^^^^^^
 >import("./foo").then : <TResult1 = { default: () => void; }, TResult2 = never>(onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                     : ^        ^^^^^^^^^^^^^^^^^^^^    ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                     : ^        ^^^^^^^^^^^^^^^^^^^^    ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >import("./foo") : Promise<{ default: () => void; }>
 >                : ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^
 >"./foo" : "./foo"
 >        : ^^^^^^^
 >then : <TResult1 = { default: () => void; }, TResult2 = never>(onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^    ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^    ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >f => {    f.default;} : (f: { default: () => void; }) => void
 >                      : ^ ^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^
 >f : { default: () => void; }
diff --git a/tests/baselines/reference/esNextWeakRefs_IterableWeakMap.types b/tests/baselines/reference/esNextWeakRefs_IterableWeakMap.types
index 2d847c5dc6a3b..0b291230cde78 100644
--- a/tests/baselines/reference/esNextWeakRefs_IterableWeakMap.types
+++ b/tests/baselines/reference/esNextWeakRefs_IterableWeakMap.types
@@ -129,13 +129,13 @@ export class IterableWeakMap<K extends object, V> implements WeakMap<K, V> {
 >this.#weakMap.get(key) : { readonly ref: WeakRef<K>; value: V; } | undefined
 >                       : ^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^^^^^^^^^^^^
 >this.#weakMap.get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
->                  : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^            
+>                  : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^^^^^^^^^^^^
 >this.#weakMap : WeakMap<K, { readonly ref: WeakRef<K>; value: V; }>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^
 >this : this
 >     : ^^^^
 >get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
->    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^            
+>    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^^^^^^^^^^^^
 >key : K
 >    : ^
 
@@ -274,13 +274,13 @@ export class IterableWeakMap<K extends object, V> implements WeakMap<K, V> {
 >this.#weakMap.get(key) : { readonly ref: WeakRef<K>; value: V; } | undefined
 >                       : ^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^^^^^^^^^^^^
 >this.#weakMap.get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
->                  : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^            
+>                  : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^^^^^^^^^^^^
 >this.#weakMap : WeakMap<K, { readonly ref: WeakRef<K>; value: V; }>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^
 >this : this
 >     : ^^^^
 >get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
->    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^            
+>    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^^^^^^^^^^^^
 >key : K
 >    : ^
 >value : V | undefined
@@ -299,13 +299,13 @@ export class IterableWeakMap<K extends object, V> implements WeakMap<K, V> {
 >this.#weakMap.get(key) : { readonly ref: WeakRef<K>; value: V; } | undefined
 >                       : ^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^^^^^^^^^^^^
 >this.#weakMap.get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
->                  : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^            
+>                  : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^^^^^^^^^^^^
 >this.#weakMap : WeakMap<K, { readonly ref: WeakRef<K>; value: V; }>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^
 >this : this
 >     : ^^^^
 >get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
->    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^            
+>    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^^^^^^^^^^^^
 >key : K
 >    : ^
 
@@ -403,11 +403,11 @@ export class IterableWeakMap<K extends object, V> implements WeakMap<K, V> {
 >ref.deref() : K | undefined
 >            : ^^^^^^^^^^^^^
 >ref.deref : () => K | undefined
->          : ^^^^^^^            
+>          : ^^^^^^^^^^^^^^^^^^^
 >ref : WeakRef<K>
 >    : ^^^^^^^^^^
 >deref : () => K | undefined
->      : ^^^^^^^            
+>      : ^^^^^^^^^^^^^^^^^^^
 
             if (key === undefined) continue;
 >key === undefined : boolean
@@ -425,13 +425,13 @@ export class IterableWeakMap<K extends object, V> implements WeakMap<K, V> {
 >this.#weakMap.get(key) : { readonly ref: WeakRef<K>; value: V; } | undefined
 >                       : ^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^^^^^^^^^^^^
 >this.#weakMap.get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
->                  : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^            
+>                  : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^^^^^^^^^^^^
 >this.#weakMap : WeakMap<K, { readonly ref: WeakRef<K>; value: V; }>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^
 >this : this
 >     : ^^^^
 >get : (key: K) => { readonly ref: WeakRef<K>; value: V; } | undefined
->    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^            
+>    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^^^^^ ^^^^^^^^^^^^^^^
 >key : K
 >    : ^
 
diff --git a/tests/baselines/reference/excessiveStackDepthFlatArray.types b/tests/baselines/reference/excessiveStackDepthFlatArray.types
index 3e6c4a9dd34f1..d465f97fc02c5 100644
--- a/tests/baselines/reference/excessiveStackDepthFlatArray.types
+++ b/tests/baselines/reference/excessiveStackDepthFlatArray.types
@@ -126,11 +126,11 @@ const Component = () => {
 >categories.map((category) => (        <li key={category}>{category}</li> // Error about 'key' only      )) : any[]
 >                                                                                                           : ^^^^^
 >categories.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >categories : string[]
 >           : ^^^^^^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(category) => (        <li key={category}>{category}</li> // Error about 'key' only      ) : (category: string) => any
 >                                                                                           : ^        ^^^^^^^^^^^^^^^^
 >category : string
diff --git a/tests/baselines/reference/expressionTypeNodeShouldError.types b/tests/baselines/reference/expressionTypeNodeShouldError.types
index 5fcf527c1cb29..b4a503438da19 100644
--- a/tests/baselines/reference/expressionTypeNodeShouldError.types
+++ b/tests/baselines/reference/expressionTypeNodeShouldError.types
@@ -67,12 +67,12 @@ type ItemType = "".typeof(nodes.item(0));
 >                : ^^^^^^^^^^^^^
 >nodes.item(0) : HTMLLIElement
 >              : ^^^^^^^^^^^^^
->nodes.item : (index: number) => HTMLLIElement | null
->           : ^     ^^      ^^^^^^^^^^^^^^^^^^       
+>nodes.item : (index: number) => HTMLLIElement
+>           : ^     ^^      ^^^^^^^^^^^^^^^^^^
 >nodes : HTMLCollectionOf<HTMLLIElement>
 >      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->item : (index: number) => HTMLLIElement | null
->     : ^     ^^      ^^^^^^^^^^^^^^^^^^       
+>item : (index: number) => HTMLLIElement
+>     : ^     ^^      ^^^^^^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 
@@ -132,12 +132,12 @@ type ItemType2 = 4..typeof(nodes.item(0));
 >                : ^^^^^^^^^^^^^
 >nodes.item(0) : HTMLLIElement
 >              : ^^^^^^^^^^^^^
->nodes.item : (index: number) => HTMLLIElement | null
->           : ^     ^^      ^^^^^^^^^^^^^^^^^^       
+>nodes.item : (index: number) => HTMLLIElement
+>           : ^     ^^      ^^^^^^^^^^^^^^^^^^
 >nodes : HTMLCollectionOf<HTMLLIElement>
 >      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->item : (index: number) => HTMLLIElement | null
->     : ^     ^^      ^^^^^^^^^^^^^^^^^^       
+>item : (index: number) => HTMLLIElement
+>     : ^     ^^      ^^^^^^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 
@@ -201,12 +201,12 @@ type ItemType3 = true.typeof(nodes.item(0));
 >                : ^^^^^^^^^^^^^
 >nodes.item(0) : HTMLLIElement
 >              : ^^^^^^^^^^^^^
->nodes.item : (index: number) => HTMLLIElement | null
->           : ^     ^^      ^^^^^^^^^^^^^^^^^^       
+>nodes.item : (index: number) => HTMLLIElement
+>           : ^     ^^      ^^^^^^^^^^^^^^^^^^
 >nodes : HTMLCollectionOf<HTMLLIElement>
 >      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->item : (index: number) => HTMLLIElement | null
->     : ^     ^^      ^^^^^^^^^^^^^^^^^^       
+>item : (index: number) => HTMLLIElement
+>     : ^     ^^      ^^^^^^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 
diff --git a/tests/baselines/reference/extendedInterfaceGenericType.types b/tests/baselines/reference/extendedInterfaceGenericType.types
index 2120e0cbde776..d7070fc89580b 100644
--- a/tests/baselines/reference/extendedInterfaceGenericType.types
+++ b/tests/baselines/reference/extendedInterfaceGenericType.types
@@ -35,11 +35,11 @@ betaOfNumber.takesArgOfT(5);
 >betaOfNumber.takesArgOfT(5) : Alpha<number>
 >                            : ^^^^^^^^^^^^^
 >betaOfNumber.takesArgOfT : (arg: number) => Alpha<number>
->                         : ^   ^^^^^^^^^^^^^      ^^^^^^ 
+>                         : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >betaOfNumber : Beta<number>
 >             : ^^^^^^^^^^^^
 >takesArgOfT : (arg: number) => Alpha<number>
->            : ^   ^^^^^^^^^^^^^      ^^^^^^ 
+>            : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >5 : 5
 >  : ^
 
diff --git a/tests/baselines/reference/findLast(target=esnext).types b/tests/baselines/reference/findLast(target=esnext).types
index 3f0ad5abfb1ba..4ed39c96d1a65 100644
--- a/tests/baselines/reference/findLast(target=esnext).types
+++ b/tests/baselines/reference/findLast(target=esnext).types
@@ -6,14 +6,14 @@ const itemNumber: number | undefined = [0].findLast((item) => item === 0);
 >           : ^^^^^^
 >[0].findLast((item) => item === 0) : 0
 >                                   : ^
->[0].findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number | undefined; }
->             : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>[0].findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number; }
+>             : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >[0] : number[]
 >    : ^^^^^^^^
 >0 : 0
 >  : ^
->findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number | undefined; }
->         : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>findLast : { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number; }
+>         : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >(item) => item === 0 : (item: number) => item is 0
 >                     : ^    ^^^^^^^^^^^^^^^^^^^^^^
 >item : number
@@ -30,14 +30,14 @@ const itemString: string | undefined = ["string"].findLast((item) => item === "s
 >           : ^^^^^^
 >["string"].findLast((item) => item === "string") : "string"
 >                                                 : ^^^^^^^^
->["string"].findLast : { <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string | undefined; }
->                    : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>["string"].findLast : { <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S; (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string; }
+>                    : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >["string"] : string[]
 >           : ^^^^^^^^
 >"string" : "string"
 >         : ^^^^^^^^
->findLast : { <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string | undefined; }
->         : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>findLast : { <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S; (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string; }
+>         : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >(item) => item === "string" : (item: string) => item is "string"
 >                            : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >item : string
@@ -52,14 +52,14 @@ const itemString: string | undefined = ["string"].findLast((item) => item === "s
 new Int8Array().findLast((item) => item === 0);
 >new Int8Array().findLast((item) => item === 0) : 0
 >                                               : ^
->new Int8Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Int8Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): number | undefined; }
->                         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^         ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^         ^^^^^       ^^       ^^^   ^^^                  ^^^
+>new Int8Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Int8Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): number | undefined; }
+>                         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^         ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^         ^^^^^       ^^       ^^^   ^^^                  ^^^
 >new Int8Array() : Int8Array
 >                : ^^^^^^^^^
 >Int8Array : Int8ArrayConstructor
 >          : ^^^^^^^^^^^^^^^^^^^^
->findLast : { <S extends number>(predicate: (value: number, index: number, array: Int8Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): number | undefined; }
->         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^         ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^         ^^^^^       ^^       ^^^   ^^^                  ^^^
+>findLast : { <S extends number>(predicate: (value: number, index: number, array: Int8Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): number | undefined; }
+>         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^         ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^         ^^^^^       ^^       ^^^   ^^^                  ^^^
 >(item) => item === 0 : (item: number) => item is 0
 >                     : ^    ^^^^^^^^^^^^^^^^^^^^^^
 >item : number
@@ -74,14 +74,14 @@ new Int8Array().findLast((item) => item === 0);
 new Uint8Array().findLast((item) => item === 0);
 >new Uint8Array().findLast((item) => item === 0) : 0
 >                                                : ^
->new Uint8Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): number | undefined; }
->                          : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^       ^^       ^^^   ^^^                  ^^^
+>new Uint8Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): number | undefined; }
+>                          : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^       ^^       ^^^   ^^^                  ^^^
 >new Uint8Array() : Uint8Array
 >                 : ^^^^^^^^^^
 >Uint8Array : Uint8ArrayConstructor
 >           : ^^^^^^^^^^^^^^^^^^^^^
->findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): number | undefined; }
->         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^       ^^       ^^^   ^^^                  ^^^
+>findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): number | undefined; }
+>         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^       ^^       ^^^   ^^^                  ^^^
 >(item) => item === 0 : (item: number) => item is 0
 >                     : ^    ^^^^^^^^^^^^^^^^^^^^^^
 >item : number
@@ -96,14 +96,14 @@ new Uint8Array().findLast((item) => item === 0);
 new Uint8ClampedArray().findLast((item) => item === 0);
 >new Uint8ClampedArray().findLast((item) => item === 0) : 0
 >                                                       : ^
->new Uint8ClampedArray().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8ClampedArray) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): number | undefined; }
->                                 : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^                 ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^                 ^^^^^       ^^       ^^^   ^^^                  ^^^
+>new Uint8ClampedArray().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8ClampedArray) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): number | undefined; }
+>                                 : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^                 ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^                 ^^^^^       ^^       ^^^   ^^^                  ^^^
 >new Uint8ClampedArray() : Uint8ClampedArray
 >                        : ^^^^^^^^^^^^^^^^^
 >Uint8ClampedArray : Uint8ClampedArrayConstructor
 >                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8ClampedArray) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): number | undefined; }
->         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^                 ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^                 ^^^^^       ^^       ^^^   ^^^                  ^^^
+>findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint8ClampedArray) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): number | undefined; }
+>         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^                 ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^                 ^^^^^       ^^       ^^^   ^^^                  ^^^
 >(item) => item === 0 : (item: number) => item is 0
 >                     : ^    ^^^^^^^^^^^^^^^^^^^^^^
 >item : number
@@ -118,14 +118,14 @@ new Uint8ClampedArray().findLast((item) => item === 0);
 new Int16Array().findLast((item) => item === 0);
 >new Int16Array().findLast((item) => item === 0) : 0
 >                                                : ^
->new Int16Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Int16Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): number | undefined; }
->                          : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^       ^^       ^^^   ^^^                  ^^^
+>new Int16Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Int16Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): number | undefined; }
+>                          : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^       ^^       ^^^   ^^^                  ^^^
 >new Int16Array() : Int16Array
 >                 : ^^^^^^^^^^
 >Int16Array : Int16ArrayConstructor
 >           : ^^^^^^^^^^^^^^^^^^^^^
->findLast : { <S extends number>(predicate: (value: number, index: number, array: Int16Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): number | undefined; }
->         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^       ^^       ^^^   ^^^                  ^^^
+>findLast : { <S extends number>(predicate: (value: number, index: number, array: Int16Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): number | undefined; }
+>         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^       ^^       ^^^   ^^^                  ^^^
 >(item) => item === 0 : (item: number) => item is 0
 >                     : ^    ^^^^^^^^^^^^^^^^^^^^^^
 >item : number
@@ -140,14 +140,14 @@ new Int16Array().findLast((item) => item === 0);
 new Uint16Array().findLast((item) => item === 0);
 >new Uint16Array().findLast((item) => item === 0) : 0
 >                                                 : ^
->new Uint16Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint16Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): number | undefined; }
->                           : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^       ^^       ^^^   ^^^                  ^^^
+>new Uint16Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint16Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): number | undefined; }
+>                           : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^       ^^       ^^^   ^^^                  ^^^
 >new Uint16Array() : Uint16Array
 >                  : ^^^^^^^^^^^
 >Uint16Array : Uint16ArrayConstructor
 >            : ^^^^^^^^^^^^^^^^^^^^^^
->findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint16Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): number | undefined; }
->         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^       ^^       ^^^   ^^^                  ^^^
+>findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint16Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): number | undefined; }
+>         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^       ^^       ^^^   ^^^                  ^^^
 >(item) => item === 0 : (item: number) => item is 0
 >                     : ^    ^^^^^^^^^^^^^^^^^^^^^^
 >item : number
@@ -162,14 +162,14 @@ new Uint16Array().findLast((item) => item === 0);
 new Int32Array().findLast((item) => item === 0);
 >new Int32Array().findLast((item) => item === 0) : 0
 >                                                : ^
->new Int32Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Int32Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): number | undefined; }
->                          : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^       ^^       ^^^   ^^^                  ^^^
+>new Int32Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Int32Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): number | undefined; }
+>                          : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^       ^^       ^^^   ^^^                  ^^^
 >new Int32Array() : Int32Array
 >                 : ^^^^^^^^^^
 >Int32Array : Int32ArrayConstructor
 >           : ^^^^^^^^^^^^^^^^^^^^^
->findLast : { <S extends number>(predicate: (value: number, index: number, array: Int32Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): number | undefined; }
->         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^       ^^       ^^^   ^^^                  ^^^
+>findLast : { <S extends number>(predicate: (value: number, index: number, array: Int32Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): number | undefined; }
+>         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^          ^^^^^       ^^       ^^^   ^^^                  ^^^
 >(item) => item === 0 : (item: number) => item is 0
 >                     : ^    ^^^^^^^^^^^^^^^^^^^^^^
 >item : number
@@ -184,14 +184,14 @@ new Int32Array().findLast((item) => item === 0);
 new Uint32Array().findLast((item) => item === 0);
 >new Uint32Array().findLast((item) => item === 0) : 0
 >                                                 : ^
->new Uint32Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint32Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): number | undefined; }
->                           : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^       ^^       ^^^   ^^^                  ^^^
+>new Uint32Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint32Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): number | undefined; }
+>                           : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^       ^^       ^^^   ^^^                  ^^^
 >new Uint32Array() : Uint32Array
 >                  : ^^^^^^^^^^^
 >Uint32Array : Uint32ArrayConstructor
 >            : ^^^^^^^^^^^^^^^^^^^^^^
->findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint32Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): number | undefined; }
->         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^       ^^       ^^^   ^^^                  ^^^
+>findLast : { <S extends number>(predicate: (value: number, index: number, array: Uint32Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): number | undefined; }
+>         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^           ^^^^^       ^^       ^^^   ^^^                  ^^^
 >(item) => item === 0 : (item: number) => item is 0
 >                     : ^    ^^^^^^^^^^^^^^^^^^^^^^
 >item : number
@@ -206,14 +206,14 @@ new Uint32Array().findLast((item) => item === 0);
 new Float32Array().findLast((item) => item === 0);
 >new Float32Array().findLast((item) => item === 0) : 0
 >                                                  : ^
->new Float32Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Float32Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): number | undefined; }
->                            : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^       ^^       ^^^   ^^^                  ^^^
+>new Float32Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Float32Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): number | undefined; }
+>                            : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^       ^^       ^^^   ^^^                  ^^^
 >new Float32Array() : Float32Array
 >                   : ^^^^^^^^^^^^
 >Float32Array : Float32ArrayConstructor
 >             : ^^^^^^^^^^^^^^^^^^^^^^^
->findLast : { <S extends number>(predicate: (value: number, index: number, array: Float32Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): number | undefined; }
->         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^       ^^       ^^^   ^^^                  ^^^
+>findLast : { <S extends number>(predicate: (value: number, index: number, array: Float32Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): number | undefined; }
+>         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^       ^^       ^^^   ^^^                  ^^^
 >(item) => item === 0 : (item: number) => item is 0
 >                     : ^    ^^^^^^^^^^^^^^^^^^^^^^
 >item : number
@@ -228,14 +228,14 @@ new Float32Array().findLast((item) => item === 0);
 new Float64Array().findLast((item) => item === 0);
 >new Float64Array().findLast((item) => item === 0) : 0
 >                                                  : ^
->new Float64Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Float64Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): number | undefined; }
->                            : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^       ^^       ^^^   ^^^                  ^^^
+>new Float64Array().findLast : { <S extends number>(predicate: (value: number, index: number, array: Float64Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): number | undefined; }
+>                            : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^       ^^       ^^^   ^^^                  ^^^
 >new Float64Array() : Float64Array
 >                   : ^^^^^^^^^^^^
 >Float64Array : Float64ArrayConstructor
 >             : ^^^^^^^^^^^^^^^^^^^^^^^
->findLast : { <S extends number>(predicate: (value: number, index: number, array: Float64Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): number | undefined; }
->         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^       ^^       ^^^   ^^^                  ^^^
+>findLast : { <S extends number>(predicate: (value: number, index: number, array: Float64Array) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): number | undefined; }
+>         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^            ^^^^^       ^^       ^^^   ^^^                  ^^^
 >(item) => item === 0 : (item: number) => item is 0
 >                     : ^    ^^^^^^^^^^^^^^^^^^^^^^
 >item : number
@@ -250,14 +250,14 @@ new Float64Array().findLast((item) => item === 0);
 new BigInt64Array().findLast((item) => item === BigInt(0));
 >new BigInt64Array().findLast((item) => item === BigInt(0)) : bigint
 >                                                           : ^^^^^^
->new BigInt64Array().findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigInt64Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: bigint, index: number, array: BigInt64Array) => unknown, thisArg?: any): bigint | undefined; }
->                             : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^             ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^             ^^^^^       ^^       ^^^   ^^^                  ^^^
+>new BigInt64Array().findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigInt64Array) => value is S, thisArg?: any): S; (predicate: (value: bigint, index: number, array: BigInt64Array) => unknown, thisArg?: any): bigint | undefined; }
+>                             : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^             ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^             ^^^^^       ^^       ^^^   ^^^                  ^^^
 >new BigInt64Array() : BigInt64Array
 >                    : ^^^^^^^^^^^^^
 >BigInt64Array : BigInt64ArrayConstructor
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^
->findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigInt64Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: bigint, index: number, array: BigInt64Array) => unknown, thisArg?: any): bigint | undefined; }
->         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^             ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^             ^^^^^       ^^       ^^^   ^^^                  ^^^
+>findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigInt64Array) => value is S, thisArg?: any): S; (predicate: (value: bigint, index: number, array: BigInt64Array) => unknown, thisArg?: any): bigint | undefined; }
+>         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^             ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^             ^^^^^       ^^       ^^^   ^^^                  ^^^
 >(item) => item === BigInt(0) : (item: bigint) => boolean
 >                             : ^    ^^^^^^^^^^^^^^^^^^^^
 >item : bigint
@@ -276,14 +276,14 @@ new BigInt64Array().findLast((item) => item === BigInt(0));
 new BigUint64Array().findLast((item) => item === BigInt(0));
 >new BigUint64Array().findLast((item) => item === BigInt(0)) : bigint
 >                                                            : ^^^^^^
->new BigUint64Array().findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigUint64Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: bigint, index: number, array: BigUint64Array) => unknown, thisArg?: any): bigint | undefined; }
->                              : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^              ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^              ^^^^^       ^^       ^^^   ^^^                  ^^^
+>new BigUint64Array().findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigUint64Array) => value is S, thisArg?: any): S; (predicate: (value: bigint, index: number, array: BigUint64Array) => unknown, thisArg?: any): bigint | undefined; }
+>                              : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^              ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^              ^^^^^       ^^       ^^^   ^^^                  ^^^
 >new BigUint64Array() : BigUint64Array
 >                     : ^^^^^^^^^^^^^^
 >BigUint64Array : BigUint64ArrayConstructor
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
->findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigUint64Array) => value is S, thisArg?: any): S | undefined; (predicate: (value: bigint, index: number, array: BigUint64Array) => unknown, thisArg?: any): bigint | undefined; }
->         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^              ^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^      ^^     ^^      ^^     ^^              ^^^^^       ^^       ^^^   ^^^                  ^^^
+>findLast : { <S extends bigint>(predicate: (value: bigint, index: number, array: BigUint64Array) => value is S, thisArg?: any): S; (predicate: (value: bigint, index: number, array: BigUint64Array) => unknown, thisArg?: any): bigint | undefined; }
+>         : ^^^ ^^^^^^^^^      ^^         ^^^     ^^      ^^     ^^      ^^     ^^              ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^      ^^     ^^      ^^     ^^              ^^^^^       ^^       ^^^   ^^^                  ^^^
 >(item) => item === BigInt(0) : (item: bigint) => boolean
 >                             : ^    ^^^^^^^^^^^^^^^^^^^^
 >item : bigint
diff --git a/tests/baselines/reference/flatArrayNoExcessiveStackDepth.types b/tests/baselines/reference/flatArrayNoExcessiveStackDepth.types
index 6027d71ea9585..e4ec2fa695c69 100644
--- a/tests/baselines/reference/flatArrayNoExcessiveStackDepth.types
+++ b/tests/baselines/reference/flatArrayNoExcessiveStackDepth.types
@@ -16,12 +16,12 @@ const bar = foo.flatMap(bar => bar as Foo);
 >    : ^^^^^^^^
 >foo.flatMap(bar => bar as Foo) : string[]
 >                               : ^^^^^^^^
->foo.flatMap : <U, This = undefined>(callback: (this: This, value: unknown, index: number, array: unknown[]) => U | ReadonlyArray<U>, thisArg?: This | undefined) => U[]
->            : ^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^                 ^ ^^       ^^^^^^^^^^^^^^^^^^^^^^^^^  
+>foo.flatMap : <U, This = undefined>(callback: (this: This, value: unknown, index: number, array: unknown[]) => U | readonly U[], thisArg?: This | undefined) => U[]
+>            : ^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >foo : unknown[]
 >    : ^^^^^^^^^
->flatMap : <U, This = undefined>(callback: (this: This, value: unknown, index: number, array: unknown[]) => U | ReadonlyArray<U>, thisArg?: This | undefined) => U[]
->        : ^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^                 ^ ^^       ^^^^^^^^^^^^^^^^^^^^^^^^^  
+>flatMap : <U, This = undefined>(callback: (this: This, value: unknown, index: number, array: unknown[]) => U | readonly U[], thisArg?: This | undefined) => U[]
+>        : ^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >bar => bar as Foo : (this: undefined, bar: unknown) => Foo
 >                  : ^    ^^^^^^^^^^^^^   ^^^^^^^^^^^^^^   
 >bar : unknown
diff --git a/tests/baselines/reference/for-of12.types b/tests/baselines/reference/for-of12.types
index 3fb732d6952e5..24c0ba69b975a 100644
--- a/tests/baselines/reference/for-of12.types
+++ b/tests/baselines/reference/for-of12.types
@@ -11,7 +11,7 @@ for (v of [0, ""].values()) { }
 >[0, ""].values() : IterableIterator<string | number>
 >                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[0, ""].values : () => IterableIterator<string | number>
->               : ^^^^^^                 ^^^^^^^^^^^^^^^ 
+>               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[0, ""] : (string | number)[]
 >        : ^^^^^^^^^^^^^^^^^^^
 >0 : 0
@@ -19,5 +19,5 @@ for (v of [0, ""].values()) { }
 >"" : ""
 >   : ^^
 >values : () => IterableIterator<string | number>
->       : ^^^^^^                 ^^^^^^^^^^^^^^^ 
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of13.types b/tests/baselines/reference/for-of13.types
index 2f9ea908034d3..6bfdc1fe849eb 100644
--- a/tests/baselines/reference/for-of13.types
+++ b/tests/baselines/reference/for-of13.types
@@ -11,11 +11,11 @@ for (v of [""].values()) { }
 >[""].values() : IterableIterator<string>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^
 >[""].values : () => IterableIterator<string>
->            : ^^^^^^                 ^^^^^^ 
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[""] : string[]
 >     : ^^^^^^^^
 >"" : ""
 >   : ^^
 >values : () => IterableIterator<string>
->       : ^^^^^^                 ^^^^^^ 
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/formatToPartsFractionalSecond.types b/tests/baselines/reference/formatToPartsFractionalSecond.types
index b6bc2489bf9ab..9880e49cca2df 100644
--- a/tests/baselines/reference/formatToPartsFractionalSecond.types
+++ b/tests/baselines/reference/formatToPartsFractionalSecond.types
@@ -4,8 +4,8 @@
 new Intl.DateTimeFormat().formatToParts().find((val) => val.type === 'fractionalSecond')
 >new Intl.DateTimeFormat().formatToParts().find((val) => val.type === 'fractionalSecond') : Intl.DateTimeFormatPart
 >                                                                                         : ^^^^^^^^^^^^^^^^^^^^^^^
->new Intl.DateTimeFormat().formatToParts().find : { <S extends Intl.DateTimeFormatPart>(predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => unknown, thisArg?: any): Intl.DateTimeFormatPart | undefined; }
->                                               : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^
+>new Intl.DateTimeFormat().formatToParts().find : { <S extends Intl.DateTimeFormatPart>(predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => value is S, thisArg?: any): S; (predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => unknown, thisArg?: any): Intl.DateTimeFormatPart; }
+>                                               : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >new Intl.DateTimeFormat().formatToParts() : Intl.DateTimeFormatPart[]
 >                                          : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >new Intl.DateTimeFormat().formatToParts : (date?: Date | number) => Intl.DateTimeFormatPart[]
@@ -20,8 +20,8 @@ new Intl.DateTimeFormat().formatToParts().find((val) => val.type === 'fractional
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >formatToParts : (date?: Date | number) => Intl.DateTimeFormatPart[]
 >              : ^    ^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  
->find : { <S extends Intl.DateTimeFormatPart>(predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => unknown, thisArg?: any): Intl.DateTimeFormatPart | undefined; }
->     : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^
+>find : { <S extends Intl.DateTimeFormatPart>(predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => value is S, thisArg?: any): S; (predicate: (value: Intl.DateTimeFormatPart, index: number, obj: Intl.DateTimeFormatPart[]) => unknown, thisArg?: any): Intl.DateTimeFormatPart; }
+>     : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(val) => val.type === 'fractionalSecond' : (val: Intl.DateTimeFormatPart) => boolean
 >                                         : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >val : Intl.DateTimeFormatPart
diff --git a/tests/baselines/reference/generatorTypeCheck62.types b/tests/baselines/reference/generatorTypeCheck62.types
index 5513f11c30875..6cf1b381d66f9 100644
--- a/tests/baselines/reference/generatorTypeCheck62.types
+++ b/tests/baselines/reference/generatorTypeCheck62.types
@@ -75,8 +75,8 @@ export interface State extends StrategicState {
 export const Nothing1: Strategy<State> = strategy("Nothing", function*(state: State) {
 >Nothing1 : Strategy<State>
 >         : ^^^^^^^^^^^^^^^
->strategy("Nothing", function*(state: State) {    return state;}) : (a: State) => IterableIterator<State | undefined>
->                                                                 : ^ ^^^^^^^^^^^^                 ^^^^^             
+>strategy("Nothing", function*(state: State) {    return state;}) : (a: State) => IterableIterator<State>
+>                                                                 : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
 >         : ^ ^^^^^^^^^              ^^         ^^      ^^   ^^                                         ^^^^^                                         
 >"Nothing" : "Nothing"
@@ -95,8 +95,8 @@ export const Nothing1: Strategy<State> = strategy("Nothing", function*(state: St
 export const Nothing2: Strategy<State> = strategy("Nothing", function*(state: State) {
 >Nothing2 : Strategy<State>
 >         : ^^^^^^^^^^^^^^^
->strategy("Nothing", function*(state: State) {    yield state;}) : (a: State) => IterableIterator<State | undefined>
->                                                                : ^ ^^^^^^^^^^^^                 ^^^^^             
+>strategy("Nothing", function*(state: State) {    yield state;}) : (a: State) => IterableIterator<State>
+>                                                                : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
 >         : ^ ^^^^^^^^^              ^^         ^^      ^^   ^^                                         ^^^^^                                         
 >"Nothing" : "Nothing"
@@ -117,8 +117,8 @@ export const Nothing2: Strategy<State> = strategy("Nothing", function*(state: St
 export const Nothing3: Strategy<State> = strategy("Nothing", function* (state: State) {
 >Nothing3 : Strategy<State>
 >         : ^^^^^^^^^^^^^^^
->strategy("Nothing", function* (state: State) {    yield ;    return state;}) : (a: any) => IterableIterator<any | undefined>
->                                                                             : ^ ^^^^^^^^^^                 ^^^             
+>strategy("Nothing", function* (state: State) {    yield ;    return state;}) : (a: any) => IterableIterator<any>
+>                                                                             : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
 >         : ^ ^^^^^^^^^              ^^         ^^      ^^   ^^                                         ^^^^^                                         
 >"Nothing" : "Nothing"
diff --git a/tests/baselines/reference/generatorTypeCheck63.types b/tests/baselines/reference/generatorTypeCheck63.types
index fb2f3c8c49a07..9efb4d642b8d7 100644
--- a/tests/baselines/reference/generatorTypeCheck63.types
+++ b/tests/baselines/reference/generatorTypeCheck63.types
@@ -75,8 +75,8 @@ export interface State extends StrategicState {
 export const Nothing: Strategy<State> = strategy("Nothing", function* (state: State) {
 >Nothing : Strategy<State>
 >        : ^^^^^^^^^^^^^^^
->strategy("Nothing", function* (state: State) {    yield 1;    return state;}) : (a: State) => IterableIterator<State | undefined>
->                                                                              : ^ ^^^^^^^^^^^^                 ^^^^^             
+>strategy("Nothing", function* (state: State) {    yield 1;    return state;}) : (a: State) => IterableIterator<State>
+>                                                                              : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
 >         : ^ ^^^^^^^^^              ^^         ^^      ^^   ^^                                         ^^^^^                                         
 >"Nothing" : "Nothing"
@@ -101,8 +101,8 @@ export const Nothing: Strategy<State> = strategy("Nothing", function* (state: St
 export const Nothing1: Strategy<State> = strategy("Nothing", function* (state: State) {
 >Nothing1 : Strategy<State>
 >         : ^^^^^^^^^^^^^^^
->strategy("Nothing", function* (state: State) {}) : (a: State) => IterableIterator<State | undefined>
->                                                 : ^ ^^^^^^^^^^^^                 ^^^^^             
+>strategy("Nothing", function* (state: State) {}) : (a: State) => IterableIterator<State>
+>                                                 : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
 >         : ^ ^^^^^^^^^              ^^         ^^      ^^   ^^                                         ^^^^^                                         
 >"Nothing" : "Nothing"
@@ -117,8 +117,8 @@ export const Nothing1: Strategy<State> = strategy("Nothing", function* (state: S
 export const Nothing2: Strategy<State> = strategy("Nothing", function* (state: State) {
 >Nothing2 : Strategy<State>
 >         : ^^^^^^^^^^^^^^^
->strategy("Nothing", function* (state: State) {    return 1;}) : (a: State) => IterableIterator<State | undefined>
->                                                              : ^ ^^^^^^^^^^^^                 ^^^^^             
+>strategy("Nothing", function* (state: State) {    return 1;}) : (a: State) => IterableIterator<State>
+>                                                              : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
 >         : ^ ^^^^^^^^^              ^^         ^^      ^^   ^^                                         ^^^^^                                         
 >"Nothing" : "Nothing"
@@ -137,8 +137,8 @@ export const Nothing2: Strategy<State> = strategy("Nothing", function* (state: S
 export const Nothing3: Strategy<State> = strategy("Nothing", function* (state: State) {
 >Nothing3 : Strategy<State>
 >         : ^^^^^^^^^^^^^^^
->strategy("Nothing", function* (state: State) {    yield state;    return 1;}) : (a: State) => IterableIterator<State | undefined>
->                                                                              : ^ ^^^^^^^^^^^^                 ^^^^^             
+>strategy("Nothing", function* (state: State) {    yield state;    return 1;}) : (a: State) => IterableIterator<State>
+>                                                                              : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined>) => (a: T) => IterableIterator<T | undefined>
 >         : ^ ^^^^^^^^^              ^^         ^^      ^^   ^^                                         ^^^^^                                         
 >"Nothing" : "Nothing"
diff --git a/tests/baselines/reference/genericArray1.types b/tests/baselines/reference/genericArray1.types
index 9cf9cc1a4ebc6..7267198ad85ca 100644
--- a/tests/baselines/reference/genericArray1.types
+++ b/tests/baselines/reference/genericArray1.types
@@ -19,7 +19,7 @@ var lengths = ["a", "b", "c"].map(x => x.length);
 >["a", "b", "c"].map(x => x.length) : number[]
 >                                   : ^^^^^^^^
 >["a", "b", "c"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->                    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >["a", "b", "c"] : string[]
 >                : ^^^^^^^^
 >"a" : "a"
@@ -29,7 +29,7 @@ var lengths = ["a", "b", "c"].map(x => x.length);
 >"c" : "c"
 >    : ^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >x => x.length : (x: string) => number
 >              : ^ ^^^^^^^^^^^^^^^^^^^
 >x : string
diff --git a/tests/baselines/reference/genericArrayMethods1.types b/tests/baselines/reference/genericArrayMethods1.types
index 0921c33834f00..d8f30c0cd4e4b 100644
--- a/tests/baselines/reference/genericArrayMethods1.types
+++ b/tests/baselines/reference/genericArrayMethods1.types
@@ -7,7 +7,7 @@ var x:string[] =  [0,1].slice(0); // this should be an error
 >[0,1].slice(0) : number[]
 >               : ^^^^^^^^
 >[0,1].slice : (start?: number, end?: number) => number[]
->            : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>            : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >[0,1] : number[]
 >      : ^^^^^^^^
 >0 : 0
@@ -15,7 +15,7 @@ var x:string[] =  [0,1].slice(0); // this should be an error
 >1 : 1
 >  : ^
 >slice : (start?: number, end?: number) => number[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 
diff --git a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.types b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.types
index 2cafec5cacfce..8ae53fb5a90bd 100644
--- a/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.types
+++ b/tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.types
@@ -31,11 +31,11 @@ module m1 {
 >numPromise.then(testFunction) : Promise<number>
 >                              : ^^^^^^^^^^^^^^^
 >numPromise.then : <U>(cb: (x: number) => Promise<U>) => Promise<U>
->                : ^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^^^^        ^ 
+>                : ^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numPromise : Promise<number>
 >           : ^^^^^^^^^^^^^^^
 >then : <U>(cb: (x: number) => Promise<U>) => Promise<U>
->     : ^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^^^^        ^ 
+>     : ^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >testFunction : (n: number) => Promise<number>
 >             : ^ ^^      ^^^^^               
 }
@@ -78,11 +78,11 @@ module m2 {
 >numPromise.then(testFunction) : Promise<string>
 >                              : ^^^^^^^^^^^^^^^
 >numPromise.then : <U>(cb: (x: number) => Promise<U>) => Promise<U>
->                : ^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^^^^        ^ 
+>                : ^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numPromise : Promise<number>
 >           : ^^^^^^^^^^^^^^^
 >then : <U>(cb: (x: number) => Promise<U>) => Promise<U>
->     : ^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^^^^        ^ 
+>     : ^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >testFunction : { (n: number): Promise<number>; (s: string): Promise<string>; }
 >             : ^^^ ^^      ^^^               ^^^ ^^      ^^^               ^^^
 }
@@ -131,11 +131,11 @@ module m3 {
 >numPromise.then(testFunction) : Promise<number>
 >                              : ^^^^^^^^^^^^^^^
 >numPromise.then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; }
->                : ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^^        ^ ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^^        ^ ^^^
+>                : ^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numPromise : Promise<number>
 >           : ^^^^^^^^^^^^^^^
 >then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; }
->     : ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^^        ^ ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^^        ^ ^^^
+>     : ^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >testFunction : (n: number) => Promise<number>
 >             : ^ ^^      ^^^^^               
 }
@@ -190,11 +190,11 @@ module m4 {
 >numPromise.then(testFunction) : Promise<string>
 >                              : ^^^^^^^^^^^^^^^
 >numPromise.then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; }
->                : ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^^        ^ ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^^        ^ ^^^
+>                : ^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numPromise : Promise<number>
 >           : ^^^^^^^^^^^^^^^
 >then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; }
->     : ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^^        ^ ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^^        ^ ^^^
+>     : ^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >testFunction : { (n: number): Promise<number>; (s: string): Promise<string>; }
 >             : ^^^ ^^      ^^^               ^^^ ^^      ^^^               ^^^
 }
@@ -265,11 +265,11 @@ module m5 {
 >numPromise.then(testFunction) : Promise<string>
 >                              : ^^^^^^^^^^^^^^^
 >numPromise.then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => U, progress?: (preservation: any) => void): Promise<U>; }
->                : ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^^        ^ ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^^        ^ ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                           ^^^        ^ ^^^
+>                : ^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                           ^^^^^^^^^^^^^^^^
 >numPromise : Promise<number>
 >           : ^^^^^^^^^^^^^^^
 >then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => U, progress?: (preservation: any) => void): Promise<U>; }
->     : ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^^        ^ ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^^        ^ ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                           ^^^        ^ ^^^
+>     : ^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                           ^^^^^^^^^^^^^^^^
 >testFunction : { (n: number): Promise<number>; (s: string): Promise<string>; }
 >             : ^^^ ^^      ^^^               ^^^ ^^      ^^^               ^^^
 }
@@ -330,11 +330,11 @@ module m6 {
 >numPromise.then(testFunction) : Promise<boolean>
 >                              : ^^^^^^^^^^^^^^^^
 >numPromise.then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; }
->                : ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^^        ^ ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^^        ^ ^^^
+>                : ^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numPromise : Promise<number>
 >           : ^^^^^^^^^^^^^^^
 >then : { <U>(cb: (x: number) => Promise<U>): Promise<U>; <U>(cb: (x: number) => Promise<U>, error?: (error: any) => Promise<U>): Promise<U>; }
->     : ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^^        ^ ^^^ ^^  ^^^ ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^^        ^ ^^^
+>     : ^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >testFunction : { (n: number): Promise<number>; (s: string): Promise<string>; (b: boolean): Promise<boolean>; }
 >             : ^^^ ^^      ^^^               ^^^ ^^      ^^^               ^^^ ^^       ^^^                ^^^
 }
diff --git a/tests/baselines/reference/genericCallWithinOwnBodyCastTypeParameterIdentity.types b/tests/baselines/reference/genericCallWithinOwnBodyCastTypeParameterIdentity.types
index 925c6b76a3a8b..da5e47d588991 100644
--- a/tests/baselines/reference/genericCallWithinOwnBodyCastTypeParameterIdentity.types
+++ b/tests/baselines/reference/genericCallWithinOwnBodyCastTypeParameterIdentity.types
@@ -57,7 +57,7 @@ const toThenable = <Result, Input>(fn: (input: Input) => Result | Thenable<Resul
 >toThenable<V, Result>(onFulfilled)(result as Result) : Thenable<V>
 >                                                     : ^^^^^^^^^^^
 >toThenable<V, Result>(onFulfilled) : (input: Result) => Thenable<V>
->                                   : ^     ^^^^^^^^^^^^^         ^ 
+>                                   : ^     ^^^^^^^^^^^^^^^^^^^^^^^^
 >toThenable : <Result, Input>(fn: (input: Input) => Result | Thenable<Result>) => (input: Input) => Thenable<Result>
 >           : ^      ^^     ^^  ^^                                           ^^^^^^     ^^     ^^^^^                
 >onFulfilled : (value: Result) => V | Thenable<V>
@@ -98,23 +98,23 @@ const toThenableInferred = <Result, Input>(fn: (input: Input) => Result | Thenab
 
         return {
 >{            then(onFulfilled) {                return toThenableInferred(onFulfilled)(result as Result)            }        } : { then<V>(onFulfilled: (value: Result) => V | Thenable<V>): Thenable<V>; }
->                                                                                                                               : ^^^^^^^ ^^           ^^^     ^^^^^^^^^^^^^^            ^ ^^^^^^^^^^^^^^^^^
+>                                                                                                                               : ^^^^^^^ ^^           ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
             then(onFulfilled) {
 >then : <V>(onFulfilled: (value: Result) => V | Thenable<V>) => Thenable<V>
->     : ^ ^^           ^^^     ^^^^^^^^^^^^^^            ^ ^^^^^^^^^^^^^^^^
+>     : ^ ^^           ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >onFulfilled : (value: Result) => V | Thenable<V>
->            : ^     ^^^^^^^^^^^^^^            ^ 
+>            : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
                 return toThenableInferred(onFulfilled)(result as Result)
 >toThenableInferred(onFulfilled)(result as Result) : Thenable<V>
 >                                                  : ^^^^^^^^^^^
 >toThenableInferred(onFulfilled) : (input: Result) => Thenable<V>
->                                : ^     ^^^^^^^^^^^^^         ^ 
+>                                : ^     ^^^^^^^^^^^^^^^^^^^^^^^^
 >toThenableInferred : <Result, Input>(fn: (input: Input) => Result | Thenable<Result>) => (input: Input) => Thenable<Result>
 >                   : ^      ^^     ^^  ^^                                           ^^^^^^     ^^     ^^^^^                
 >onFulfilled : (value: Result) => V | Thenable<V>
->            : ^     ^^^^^^^^^^^^^^            ^ 
+>            : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >result as Result : Result
 >                 : ^^^^^^
 >result : Result | Thenable<Result>
diff --git a/tests/baselines/reference/genericChainedCalls.types b/tests/baselines/reference/genericChainedCalls.types
index 53a48ab5ec1fb..d788ea4d023b9 100644
--- a/tests/baselines/reference/genericChainedCalls.types
+++ b/tests/baselines/reference/genericChainedCalls.types
@@ -21,19 +21,19 @@ var r1 = v1.func(num => num.toString())
 >v1.func(num => num.toString())            .func(str => str.length) // error, number doesn't have a length           .func(num => num.toString()) : I1<number>
 >                                                                                                                                                 : ^^^^^^^^^^
 >v1.func(num => num.toString())            .func(str => str.length) // error, number doesn't have a length           .func : <U>(callback: (value: number) => U) => I1<number>
->                                                                                                                          : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^^^^^^ 
+>                                                                                                                          : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >v1.func(num => num.toString())            .func(str => str.length) : I1<number>
 >                                                                   : ^^^^^^^^^^
 >v1.func(num => num.toString())            .func : <U>(callback: (value: number) => U) => I1<number>
->                                                : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^^^^^^ 
+>                                                : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >v1.func(num => num.toString()) : I1<number>
 >                               : ^^^^^^^^^^
 >v1.func : <U>(callback: (value: number) => U) => I1<number>
->        : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^^^^^^ 
+>        : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >v1 : I1<number>
 >   : ^^^^^^^^^^
 >func : <U>(callback: (value: number) => U) => I1<number>
->     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^^^^^^ 
+>     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >num => num.toString() : (num: number) => string
 >                      : ^   ^^^^^^^^^^^^^^^^^^^
 >num : number
@@ -49,7 +49,7 @@ var r1 = v1.func(num => num.toString())
 
            .func(str => str.length) // error, number doesn't have a length
 >func : <U>(callback: (value: number) => U) => I1<number>
->     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^^^^^^ 
+>     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >str => str.length : (str: number) => any
 >                  : ^   ^^^^^^^^^^^^^^^^
 >str : number
@@ -63,7 +63,7 @@ var r1 = v1.func(num => num.toString())
 
            .func(num => num.toString())
 >func : <U>(callback: (value: number) => U) => I1<number>
->     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^^^^^^ 
+>     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >num => num.toString() : (num: number) => string
 >                      : ^   ^^^^^^^^^^^^^^^^^^^
 >num : number
@@ -83,11 +83,11 @@ var s1 = v1.func(num => num.toString())
 >v1.func(num => num.toString()) : I1<number>
 >                               : ^^^^^^^^^^
 >v1.func : <U>(callback: (value: number) => U) => I1<number>
->        : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^^^^^^ 
+>        : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >v1 : I1<number>
 >   : ^^^^^^^^^^
 >func : <U>(callback: (value: number) => U) => I1<number>
->     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^^^^^^ 
+>     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >num => num.toString() : (num: number) => string
 >                      : ^   ^^^^^^^^^^^^^^^^^^^
 >num : number
@@ -107,11 +107,11 @@ var s2 = s1.func(str => str.length) // should also error
 >s1.func(str => str.length) : I1<number>
 >                           : ^^^^^^^^^^
 >s1.func : <U>(callback: (value: number) => U) => I1<number>
->        : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^^^^^^ 
+>        : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s1 : I1<number>
 >   : ^^^^^^^^^^
 >func : <U>(callback: (value: number) => U) => I1<number>
->     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^^^^^^ 
+>     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >str => str.length : (str: number) => any
 >                  : ^   ^^^^^^^^^^^^^^^^
 >str : number
@@ -129,11 +129,11 @@ var s3 = s2.func(num => num.toString())
 >s2.func(num => num.toString()) : I1<number>
 >                               : ^^^^^^^^^^
 >s2.func : <U>(callback: (value: number) => U) => I1<number>
->        : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^^^^^^ 
+>        : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s2 : I1<number>
 >   : ^^^^^^^^^^
 >func : <U>(callback: (value: number) => U) => I1<number>
->     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^^^^^^ 
+>     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >num => num.toString() : (num: number) => string
 >                      : ^   ^^^^^^^^^^^^^^^^^^^
 >num : number
diff --git a/tests/baselines/reference/genericClassWithStaticsUsingTypeArguments.types b/tests/baselines/reference/genericClassWithStaticsUsingTypeArguments.types
index 5038a6282eff3..673dd58110312 100644
--- a/tests/baselines/reference/genericClassWithStaticsUsingTypeArguments.types
+++ b/tests/baselines/reference/genericClassWithStaticsUsingTypeArguments.types
@@ -64,11 +64,11 @@ class Foo<T> {
 >xs.reverse() : T[]
 >             : ^^^
 >xs.reverse : () => T[]
->           : ^^^^^^^  
+>           : ^^^^^^^^^
 >xs : T[]
 >   : ^^^
 >reverse : () => T[]
->        : ^^^^^^^  
+>        : ^^^^^^^^^
     }
 }
 
diff --git a/tests/baselines/reference/genericContextualTypes1.types b/tests/baselines/reference/genericContextualTypes1.types
index a1a7c3eae285d..8501eb750fa2d 100644
--- a/tests/baselines/reference/genericContextualTypes1.types
+++ b/tests/baselines/reference/genericContextualTypes1.types
@@ -249,11 +249,11 @@ const arrayMap = <T, U>(f: (x: T) => U) => (a: T[]) => a.map(f);
 >a.map(f) : U[]
 >         : ^^^
 >a.map : <U_1>(callbackfn: (value: T, index: number, array: T[]) => U_1, thisArg?: any) => U_1[]
->      : ^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^  
+>      : ^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^
 >a : T[]
 >  : ^^^
 >map : <U_1>(callbackfn: (value: T, index: number, array: T[]) => U_1, thisArg?: any) => U_1[]
->    : ^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^  
+>    : ^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^
 >f : (x: T) => U
 >  : ^ ^^ ^^^^^ 
 
@@ -273,11 +273,11 @@ const arrayFilter = <T>(f: (x: T) => boolean) => (a: T[]) => a.filter(f);
 >a.filter(f) : T[]
 >            : ^^^
 >a.filter : { <S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; (predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; }
->         : ^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^^  ^^^
+>         : ^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^
 >a : T[]
 >  : ^^^
 >filter : { <S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; (predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; }
->       : ^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^
 >f : (x: T) => boolean
 >  : ^ ^^ ^^^^^       
 
diff --git a/tests/baselines/reference/genericFunctionInference1.types b/tests/baselines/reference/genericFunctionInference1.types
index b3712e7819407..e973ef58a7da3 100644
--- a/tests/baselines/reference/genericFunctionInference1.types
+++ b/tests/baselines/reference/genericFunctionInference1.types
@@ -561,9 +561,9 @@ declare function pipe2<A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D): (a: [A, C]
 
 const f20 = pipe2(list, box);
 >f20 : <T, V>(a: [T, V]) => [T[], { value: V; }]
->    : ^ ^^ ^^ ^^^^^^^^^^^^^ ^^^  ^^^^^^^^^ ^^^ 
+>    : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
 >pipe2(list, box) : <T, V>(a: [T, V]) => [T[], { value: V; }]
->                 : ^ ^^ ^^ ^^^^^^^^^^^^^ ^^^  ^^^^^^^^^ ^^^ 
+>                 : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
 >pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
 >      : ^ ^^ ^^ ^^ ^^  ^^           ^^  ^^           ^^^^^                     
 >list : <T>(a: T) => T[]
@@ -573,9 +573,9 @@ const f20 = pipe2(list, box);
 
 const f21 = pipe2(box, list);
 >f21 : <V, T>(a: [V, T]) => [{ value: V; }, T[]]
->    : ^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^ ^^^  ^^^ 
+>    : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
 >pipe2(box, list) : <V, T>(a: [V, T]) => [{ value: V; }, T[]]
->                 : ^ ^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^^ ^^^  ^^^ 
+>                 : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
 >pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
 >      : ^ ^^ ^^ ^^ ^^  ^^           ^^  ^^           ^^^^^                     
 >box : <V>(x: V) => { value: V; }
@@ -585,9 +585,9 @@ const f21 = pipe2(box, list);
 
 const f22 = pipe2(list, list);
 >f22 : <T, T1>(a: [T, T1]) => [T[], T1[]]
->    : ^ ^^^^^^ ^^^^^^^^^^^^^^ ^^^  ^^^^ 
+>    : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >pipe2(list, list) : <T, T1>(a: [T, T1]) => [T[], T1[]]
->                  : ^ ^^^^^^ ^^^^^^^^^^^^^^ ^^^  ^^^^ 
+>                  : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
 >      : ^ ^^ ^^ ^^ ^^  ^^           ^^  ^^           ^^^^^                     
 >list : <T>(a: T) => T[]
@@ -597,9 +597,9 @@ const f22 = pipe2(list, list);
 
 const f23 = pipe2(box, box);
 >f23 : <V, V1>(a: [V, V1]) => [{ value: V; }, { value: V1; }]
->    : ^ ^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^  ^^^^^^^^^^^^^^ 
+>    : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
 >pipe2(box, box) : <V, V1>(a: [V, V1]) => [{ value: V; }, { value: V1; }]
->                : ^ ^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^  ^^^^^^^^^^^^^^ 
+>                : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
 >pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
 >      : ^ ^^ ^^ ^^ ^^  ^^           ^^  ^^           ^^^^^                     
 >box : <V>(x: V) => { value: V; }
@@ -609,21 +609,21 @@ const f23 = pipe2(box, box);
 
 const f24 = pipe2(f20, f20);
 >f24 : <T, V, T1, V1>(a: [[T, V], [T1, V1]]) => [[T[], { value: V; }], [T1[], { value: V1; }]]
->    : ^ ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^  ^^^^^^^^^^^^^^^^^^^^^^ 
+>    : ^ ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >pipe2(f20, f20) : <T, V, T1, V1>(a: [[T, V], [T1, V1]]) => [[T[], { value: V; }], [T1[], { value: V1; }]]
->                : ^ ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^  ^^^^^^^^^^^^^^^^^^^^^^ 
+>                : ^ ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
 >      : ^ ^^ ^^ ^^ ^^  ^^           ^^  ^^           ^^^^^                     
 >f20 : <T, V>(a: [T, V]) => [T[], { value: V; }]
->    : ^ ^^ ^^ ^^^^^^^^^^^^^ ^^^  ^^^^^^^^^ ^^^ 
+>    : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
 >f20 : <T, V>(a: [T, V]) => [T[], { value: V; }]
->    : ^ ^^ ^^ ^^^^^^^^^^^^^ ^^^  ^^^^^^^^^ ^^^ 
+>    : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
 
 const f25 = pipe2(foo, foo);
 >f25 : <T extends { value: T; }, T1 extends { value: T1; }>(a: [T, T1]) => [T, T1]
->    : ^ ^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^  ^^ 
+>    : ^ ^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
 >pipe2(foo, foo) : <T extends { value: T; }, T1 extends { value: T1; }>(a: [T, T1]) => [T, T1]
->                : ^ ^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^  ^^ 
+>                : ^ ^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
 >pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
 >      : ^ ^^ ^^ ^^ ^^  ^^           ^^  ^^           ^^^^^                     
 >foo : <T extends { value: T; }>(x: T) => T
@@ -633,15 +633,15 @@ const f25 = pipe2(foo, foo);
 
 const f26 = pipe2(f25, f25);
 >f26 : <T extends { value: T; }, T1 extends { value: T1; }, T2 extends { value: T2; }, T3 extends { value: T3; }>(a: [[T, T1], [T2, T3]]) => [[T, T1], [T2, T3]]
->    : ^ ^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^  ^^^^^^^^ 
+>    : ^ ^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >pipe2(f25, f25) : <T extends { value: T; }, T1 extends { value: T1; }, T2 extends { value: T2; }, T3 extends { value: T3; }>(a: [[T, T1], [T2, T3]]) => [[T, T1], [T2, T3]]
->                : ^ ^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^  ^^^^^^^^ 
+>                : ^ ^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >pipe2 : <A, B, C, D>(ab: (a: A) => B, cd: (c: C) => D) => (a: [A, C]) => [B, D]
 >      : ^ ^^ ^^ ^^ ^^  ^^           ^^  ^^           ^^^^^                     
 >f25 : <T extends { value: T; }, T1 extends { value: T1; }>(a: [T, T1]) => [T, T1]
->    : ^ ^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^  ^^ 
+>    : ^ ^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
 >f25 : <T extends { value: T; }, T1 extends { value: T1; }>(a: [T, T1]) => [T, T1]
->    : ^ ^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^  ^^ 
+>    : ^ ^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
 
 declare function pipe3<A, B, C>(ab: (a: A) => B, ac: (a: A) => C): (a: A) => [B, C];
 >pipe3 : <A, B, C>(ab: (a: A) => B, ac: (a: A) => C) => (a: A) => [B, C]
@@ -659,9 +659,9 @@ declare function pipe3<A, B, C>(ab: (a: A) => B, ac: (a: A) => C): (a: A) => [B,
 
 const f30 = pipe3(list, box);
 >f30 : <T>(a: T) => [T[], { value: T; }]
->    : ^ ^^ ^^^^^^^^ ^^^  ^^^^^^^^^^^^^ 
+>    : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >pipe3(list, box) : <T>(a: T) => [T[], { value: T; }]
->                 : ^ ^^ ^^^^^^^^ ^^^  ^^^^^^^^^^^^^ 
+>                 : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >pipe3 : <A, B, C>(ab: (a: A) => B, ac: (a: A) => C) => (a: A) => [B, C]
 >      : ^ ^^ ^^ ^^  ^^           ^^  ^^           ^^^^^                
 >list : <T>(a: T) => T[]
@@ -671,9 +671,9 @@ const f30 = pipe3(list, box);
 
 const f31 = pipe3(box, list);
 >f31 : <V>(a: V) => [{ value: V; }, V[]]
->    : ^ ^^ ^^^^^^^^ ^^^^^^^^^ ^^^  ^^^ 
+>    : ^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
 >pipe3(box, list) : <V>(a: V) => [{ value: V; }, V[]]
->                 : ^ ^^ ^^^^^^^^ ^^^^^^^^^ ^^^  ^^^ 
+>                 : ^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
 >pipe3 : <A, B, C>(ab: (a: A) => B, ac: (a: A) => C) => (a: A) => [B, C]
 >      : ^ ^^ ^^ ^^  ^^           ^^  ^^           ^^^^^                
 >box : <V>(x: V) => { value: V; }
@@ -683,9 +683,9 @@ const f31 = pipe3(box, list);
 
 const f32 = pipe3(list, list);
 >f32 : <T>(a: T) => [T[], T[]]
->    : ^ ^^ ^^^^^^^^ ^^^  ^^^ 
+>    : ^ ^^ ^^^^^^^^^^^^^^^^^^
 >pipe3(list, list) : <T>(a: T) => [T[], T[]]
->                  : ^ ^^ ^^^^^^^^ ^^^  ^^^ 
+>                  : ^ ^^ ^^^^^^^^^^^^^^^^^^
 >pipe3 : <A, B, C>(ab: (a: A) => B, ac: (a: A) => C) => (a: A) => [B, C]
 >      : ^ ^^ ^^ ^^  ^^           ^^  ^^           ^^^^^                
 >list : <T>(a: T) => T[]
@@ -1008,9 +1008,9 @@ declare class GenericComp<T> extends Comp<GenericProps<T>> {}
 
 const GenericComp2 = myHoc(GenericComp);
 >GenericComp2 : new <T>(props: GenericProps<T>) => Comp<GenericProps<T>>
->             : ^^^^^ ^^     ^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^ 
+>             : ^^^^^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >myHoc(GenericComp) : new <T>(props: GenericProps<T>) => Comp<GenericProps<T>>
->                   : ^^^^^ ^^     ^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^ 
+>                   : ^^^^^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >myHoc : <P>(C: CompClass<P>) => CompClass<P>
 >      : ^ ^^ ^^            ^^^^^            
 >GenericComp : typeof GenericComp
@@ -1213,11 +1213,11 @@ const map = <T, U>(transform: (t: T) => U) =>
 >arr.map(transform) : U[]
 >                   : ^^^
 >arr.map : <U_1>(callbackfn: (value: T, index: number, array: T[]) => U_1, thisArg?: any) => U_1[]
->        : ^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^  
+>        : ^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^
 >arr : T[]
 >    : ^^^
 >map : <U_1>(callbackfn: (value: T, index: number, array: T[]) => U_1, thisArg?: any) => U_1[]
->    : ^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^  
+>    : ^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^
 >transform : (t: T) => U
 >          : ^ ^^ ^^^^^ 
 
@@ -1422,11 +1422,11 @@ promise.then(
 >promise.then(    pipe(        x => x + 1,        x => x * 2,    ),) : Promise<number>
 >                                                                    : ^^^^^^^^^^^^^^^
 >promise.then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->             : ^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>             : ^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >promise : Promise<number>
 >        : ^^^^^^^^^^^^^^^
 >then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     pipe(
 >pipe(        x => x + 1,        x => x * 2,    ) : (x: number) => number
@@ -1659,7 +1659,7 @@ const a2 = times(identity)(5); // => [0, 1, 2, 3, 4]
 >times(identity)(5) : number[]
 >                   : ^^^^^^^^
 >times(identity) : (n: number) => number[]
->                : ^ ^^      ^^^^^^^^^^^  
+>                : ^ ^^      ^^^^^^^^^^^^^
 >times : <T>(fn: (i: number) => T) => (n: number) => T[]
 >      : ^ ^^  ^^                ^^^^^                  
 >identity : <T>(value: T) => T
diff --git a/tests/baselines/reference/genericFunctionsAndConditionalInference.types b/tests/baselines/reference/genericFunctionsAndConditionalInference.types
index 006a2345ec46b..057667bb7c6f6 100644
--- a/tests/baselines/reference/genericFunctionsAndConditionalInference.types
+++ b/tests/baselines/reference/genericFunctionsAndConditionalInference.types
@@ -141,11 +141,11 @@ const ok = <F extends Target>(at: Ops<F>) => ({lr: at.lr(at.str, at.num)})
 >at.lr(at.str, at.num) : Result<F, LR<F, string, number>>
 >                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >at.lr : <I, O>(a: Result<F, I>, o: Result<F, O>) => Result<F, LR<F, I, O>>
->      : ^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^       ^     ^  ^  ^  
+>      : ^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >at : Ops<F>
 >   : ^^^^^^
 >lr : <I, O>(a: Result<F, I>, o: Result<F, O>) => Result<F, LR<F, I, O>>
->   : ^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^       ^     ^  ^  ^  
+>   : ^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >at.str : Result<F, string>
 >       : ^^^^^^^^^^^^^^^^^
 >at : Ops<F>
@@ -169,11 +169,11 @@ const orphaned = <F extends Target>(at: Ops<F>) => at.dict(ok(at))
 >at.dict(ok(at)) : Result<F, { lr: LR<F, string, number>; }>
 >                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >at.dict : <P>(p: { [k in keyof P]: Result<F, P[k]>; }) => Result<F, P>
->        : ^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^  ^ 
+>        : ^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >at : Ops<F>
 >   : ^^^^^^
 >dict : <P>(p: { [k in keyof P]: Result<F, P[k]>; }) => Result<F, P>
->     : ^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^  ^ 
+>     : ^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >ok(at) : { lr: Result<F, LR<F, string, number>>; }
 >       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >ok : <F_1 extends Target>(at: Ops<F_1>) => { lr: Result<F_1, LR<F_1, string, number>>; }
diff --git a/tests/baselines/reference/genericInference1.types b/tests/baselines/reference/genericInference1.types
index 8c5b5deb5a66c..977764bb6b603 100644
--- a/tests/baselines/reference/genericInference1.types
+++ b/tests/baselines/reference/genericInference1.types
@@ -5,7 +5,7 @@
 >['a', 'b', 'c'].map(x => x.length) : number[]
 >                                   : ^^^^^^^^
 >['a', 'b', 'c'].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->                    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >['a', 'b', 'c'] : string[]
 >                : ^^^^^^^^
 >'a' : "a"
@@ -15,7 +15,7 @@
 >'c' : "c"
 >    : ^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >x => x.length : (x: string) => number
 >              : ^ ^^^^^^^^^^^^^^^^^^^
 >x : string
diff --git a/tests/baselines/reference/genericMethodOverspecialization.types b/tests/baselines/reference/genericMethodOverspecialization.types
index 1341874c8a707..690043e4f1c50 100644
--- a/tests/baselines/reference/genericMethodOverspecialization.types
+++ b/tests/baselines/reference/genericMethodOverspecialization.types
@@ -45,11 +45,11 @@ var elements = names.map(function (name) {
 >names.map(function (name) {    return document.getElementById(name);}) : HTMLElement[]
 >                                                                       : ^^^^^^^^^^^^^
 >names.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->          : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>          : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >names : string[]
 >      : ^^^^^^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >function (name) {    return document.getElementById(name);} : (name: string) => HTMLElement
 >                                                            : ^    ^^^^^^^^^^^^^^^^^^^^^^^^
 >name : string
@@ -76,11 +76,11 @@ var xxx = elements.filter(function (e) {
 >elements.filter(function (e) {    return !e.isDisabled;}) : HTMLElement[]
 >                                                          : ^^^^^^^^^^^^^
 >elements.filter : { <S extends HTMLElement>(predicate: (value: HTMLElement, index: number, array: HTMLElement[]) => value is S, thisArg?: any): S[]; (predicate: (value: HTMLElement, index: number, array: HTMLElement[]) => unknown, thisArg?: any): HTMLElement[]; }
->                : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^  ^^^
+>                : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^
 >elements : HTMLElement[]
 >         : ^^^^^^^^^^^^^
 >filter : { <S extends HTMLElement>(predicate: (value: HTMLElement, index: number, array: HTMLElement[]) => value is S, thisArg?: any): S[]; (predicate: (value: HTMLElement, index: number, array: HTMLElement[]) => unknown, thisArg?: any): HTMLElement[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^
 >function (e) {    return !e.isDisabled;} : (e: HTMLElement) => boolean
 >                                         : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >e : HTMLElement
@@ -104,11 +104,11 @@ var widths:number[] = elements.map(function (e) { // should not error
 >elements.map(function (e) { // should not error    return e.clientWidth;}) : number[]
 >                                                                           : ^^^^^^^^
 >elements.map : <U>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[]
->             : ^ ^^          ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>             : ^ ^^          ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >elements : HTMLElement[]
 >         : ^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >function (e) { // should not error    return e.clientWidth;} : (e: HTMLElement) => number
 >                                                             : ^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >e : HTMLElement
diff --git a/tests/baselines/reference/genericReduce.types b/tests/baselines/reference/genericReduce.types
index 35b2981dd13b9..147a70473d2d4 100644
--- a/tests/baselines/reference/genericReduce.types
+++ b/tests/baselines/reference/genericReduce.types
@@ -21,11 +21,11 @@ var b = a.map(s => s.length);
 >a.map(s => s.length) : number[]
 >                     : ^^^^^^^^
 >a.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->      : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>      : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >a : string[]
 >  : ^^^^^^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >s => s.length : (s: string) => number
 >              : ^ ^^^^^^^^^^^^^^^^^^^
 >s : string
diff --git a/tests/baselines/reference/genericReversingTypeParameters.types b/tests/baselines/reference/genericReversingTypeParameters.types
index a9ee4ec20c809..0d841756ec189 100644
--- a/tests/baselines/reference/genericReversingTypeParameters.types
+++ b/tests/baselines/reference/genericReversingTypeParameters.types
@@ -48,11 +48,11 @@ var i = b.inverse(); // used to get the type wrong here.
 >b.inverse() : BiMap<number, string>
 >            : ^^^^^^^^^^^^^^^^^^^^^
 >b.inverse : () => BiMap<number, string>
->          : ^^^^^^      ^^^^^^  ^^^^^^ 
+>          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >b : BiMap<string, number>
 >  : ^^^^^^^^^^^^^^^^^^^^^
 >inverse : () => BiMap<number, string>
->        : ^^^^^^      ^^^^^^  ^^^^^^ 
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 var r2b = i.get(1); 
 >r2b : string
diff --git a/tests/baselines/reference/genericReversingTypeParameters2.types b/tests/baselines/reference/genericReversingTypeParameters2.types
index 0791f8e5dfb5c..c21115317d619 100644
--- a/tests/baselines/reference/genericReversingTypeParameters2.types
+++ b/tests/baselines/reference/genericReversingTypeParameters2.types
@@ -34,11 +34,11 @@ var i = b.inverse(); // used to get the type wrong here.
 >b.inverse() : BiMap<number, string>
 >            : ^^^^^^^^^^^^^^^^^^^^^
 >b.inverse : () => BiMap<number, string>
->          : ^^^^^^      ^^^^^^  ^^^^^^ 
+>          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >b : BiMap<string, number>
 >  : ^^^^^^^^^^^^^^^^^^^^^
 >inverse : () => BiMap<number, string>
->        : ^^^^^^      ^^^^^^  ^^^^^^ 
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 var r2b = i.get(1); 
 >r2b : string
diff --git a/tests/baselines/reference/genericTypeParameterEquivalence2.types b/tests/baselines/reference/genericTypeParameterEquivalence2.types
index 9a9cb82a1790b..3f77e182574ac 100644
--- a/tests/baselines/reference/genericTypeParameterEquivalence2.types
+++ b/tests/baselines/reference/genericTypeParameterEquivalence2.types
@@ -204,9 +204,9 @@ function curry1<A, B, C>(f: (a: A, b: B) => C): (ax: A) => (bx: B) => C {
 
 var cfilter = curry1(filter);
 >cfilter : <A>(ax: (a: A) => boolean) => (bx: A[]) => A[]
->        : ^ ^^  ^^^ ^^ ^^^^^       ^^^^^     ^^^     ^^^
+>        : ^ ^^  ^^^ ^^ ^^^^^       ^^^^^^  ^^^^^^^^^^^^^
 >curry1(filter) : <A>(ax: (a: A) => boolean) => (bx: A[]) => A[]
->               : ^ ^^  ^^^ ^^ ^^^^^       ^^^^^     ^^^     ^^^
+>               : ^ ^^  ^^^ ^^ ^^^^^       ^^^^^^  ^^^^^^^^^^^^^
 >curry1 : <A, B, C>(f: (a: A, b: B) => C) => (ax: A) => (bx: B) => C
 >       : ^ ^^ ^^ ^^ ^^                 ^^^^^                       
 >filter : <A>(f: (a: A) => boolean, ar: A[]) => A[]
@@ -240,7 +240,7 @@ function countWhere_1<A>(pred: (a: A) => boolean): (a: A[]) => number {
 >cfilter(pred) : (bx: A[]) => A[]
 >              : ^  ^^^^^^^^^^^^^
 >cfilter : <A_1>(ax: (a: A_1) => boolean) => (bx: A_1[]) => A_1[]
->        : ^^^^^^  ^^^ ^^   ^^^^^       ^^^^^     ^^^^^     ^^^^^
+>        : ^^^^^^  ^^^ ^^   ^^^^^       ^^^^^^  ^^^^^^^^^^^^^^^^^
 >pred : (a: A) => boolean
 >     : ^ ^^ ^^^^^       
 }
@@ -261,7 +261,7 @@ function countWhere_2<A>(pred: (a: A) => boolean): (a: A[]) => number {
 >cfilter(pred) : (bx: A[]) => A[]
 >              : ^  ^^^^^^^^^^^^^
 >cfilter : <A_1>(ax: (a: A_1) => boolean) => (bx: A_1[]) => A_1[]
->        : ^^^^^^  ^^^ ^^   ^^^^^       ^^^^^     ^^^^^     ^^^^^
+>        : ^^^^^^  ^^^ ^^   ^^^^^       ^^^^^^  ^^^^^^^^^^^^^^^^^
 >pred : (a: A) => boolean
 >     : ^ ^^ ^^^^^       
 
diff --git a/tests/baselines/reference/genericsAndHigherOrderFunctions.types b/tests/baselines/reference/genericsAndHigherOrderFunctions.types
index 90f1d9196227a..a3fa4690539b9 100644
--- a/tests/baselines/reference/genericsAndHigherOrderFunctions.types
+++ b/tests/baselines/reference/genericsAndHigherOrderFunctions.types
@@ -121,7 +121,7 @@ var foo: <K, N>(g: (x: K) => N) =>
 >combine(f)(g) : (x: K) => (_: R) => R
 >              : ^ ^^^^^^^^^ ^^ ^^^^^ 
 >combine(f) : <U>(g: (_: U) => N) => (x: U) => (_: R) => R
->           : ^ ^^ ^^^ ^^^^^^^^^^^^^^    ^     ^ ^^ ^^^^^ 
+>           : ^ ^^ ^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^ ^^^^^ 
 >combine : <T, S>(f: (_: T) => S) => <U>(g: (_: U) => T) => (x: U) => S
 >        : ^ ^^ ^^ ^^           ^^^^^                                  
 >f : (_: N) => (_: R) => R
diff --git a/tests/baselines/reference/importCallExpression1ES2020.types b/tests/baselines/reference/importCallExpression1ES2020.types
index 59865043efc15..3ff1bcaaed336 100644
--- a/tests/baselines/reference/importCallExpression1ES2020.types
+++ b/tests/baselines/reference/importCallExpression1ES2020.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpression2ES2020.types b/tests/baselines/reference/importCallExpression2ES2020.types
index 276a5c89257fa..9ecd73e8e55b9 100644
--- a/tests/baselines/reference/importCallExpression2ES2020.types
+++ b/tests/baselines/reference/importCallExpression2ES2020.types
@@ -23,11 +23,11 @@ function foo(x: Promise<any>) {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
 >                                                                        : ^^^^^^^^^^^^^
 >x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : Promise<any>
 >  : ^^^^^^^^^^^^
 >then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >                                                                : ^     ^^^^^^^^^^^^^^
 >value : any
diff --git a/tests/baselines/reference/importCallExpression4ES2020.types b/tests/baselines/reference/importCallExpression4ES2020.types
index d995d46e4766f..e1ef783a6dfc7 100644
--- a/tests/baselines/reference/importCallExpression4ES2020.types
+++ b/tests/baselines/reference/importCallExpression4ES2020.types
@@ -57,7 +57,7 @@ class C {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
 >                                                                                                                                                                                                                 : ^^^^^^^^^^^^^
 >this.myModule.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.myModule : Promise<typeof import("0")>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this : this
@@ -65,7 +65,7 @@ class C {
 >myModule : Promise<typeof import("0")>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("0")) => void
 >                                                       : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionES5AMD.types b/tests/baselines/reference/importCallExpressionES5AMD.types
index 6f2fdb580068e..48f71779df78e 100644
--- a/tests/baselines/reference/importCallExpressionES5AMD.types
+++ b/tests/baselines/reference/importCallExpressionES5AMD.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionES5CJS.types b/tests/baselines/reference/importCallExpressionES5CJS.types
index 5ad5b42a9ee1c..ce3f268a559db 100644
--- a/tests/baselines/reference/importCallExpressionES5CJS.types
+++ b/tests/baselines/reference/importCallExpressionES5CJS.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionES5System.types b/tests/baselines/reference/importCallExpressionES5System.types
index 7cc20e70f6025..5c7e4e511afb0 100644
--- a/tests/baselines/reference/importCallExpressionES5System.types
+++ b/tests/baselines/reference/importCallExpressionES5System.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionES5UMD.types b/tests/baselines/reference/importCallExpressionES5UMD.types
index 2b85342c9c510..e08c6db4b20e3 100644
--- a/tests/baselines/reference/importCallExpressionES5UMD.types
+++ b/tests/baselines/reference/importCallExpressionES5UMD.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionES6AMD.types b/tests/baselines/reference/importCallExpressionES6AMD.types
index c32b036a35bfe..4611ae282b91b 100644
--- a/tests/baselines/reference/importCallExpressionES6AMD.types
+++ b/tests/baselines/reference/importCallExpressionES6AMD.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionES6CJS.types b/tests/baselines/reference/importCallExpressionES6CJS.types
index 687fc37a44f12..6b9d5a041d492 100644
--- a/tests/baselines/reference/importCallExpressionES6CJS.types
+++ b/tests/baselines/reference/importCallExpressionES6CJS.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionES6System.types b/tests/baselines/reference/importCallExpressionES6System.types
index 4ab6de12d67c3..eea3381a651ff 100644
--- a/tests/baselines/reference/importCallExpressionES6System.types
+++ b/tests/baselines/reference/importCallExpressionES6System.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionES6UMD.types b/tests/baselines/reference/importCallExpressionES6UMD.types
index 4560906b8e112..22c85a6070b29 100644
--- a/tests/baselines/reference/importCallExpressionES6UMD.types
+++ b/tests/baselines/reference/importCallExpressionES6UMD.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionErrorInES2015.types b/tests/baselines/reference/importCallExpressionErrorInES2015.types
index 22bc7168c39cf..7906be1887e8d 100644
--- a/tests/baselines/reference/importCallExpressionErrorInES2015.types
+++ b/tests/baselines/reference/importCallExpressionErrorInES2015.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionInAMD1.types b/tests/baselines/reference/importCallExpressionInAMD1.types
index acdd17d10c912..30a7ad724c4cd 100644
--- a/tests/baselines/reference/importCallExpressionInAMD1.types
+++ b/tests/baselines/reference/importCallExpressionInAMD1.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionInAMD2.types b/tests/baselines/reference/importCallExpressionInAMD2.types
index 37f29df86c64a..940c187c061dc 100644
--- a/tests/baselines/reference/importCallExpressionInAMD2.types
+++ b/tests/baselines/reference/importCallExpressionInAMD2.types
@@ -24,11 +24,11 @@ function foo(x: Promise<any>) {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
 >                                                                        : ^^^^^^^^^^^^^
 >x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : Promise<any>
 >  : ^^^^^^^^^^^^
 >then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >                                                                : ^     ^^^^^^^^^^^^^^
 >value : any
diff --git a/tests/baselines/reference/importCallExpressionInAMD4.types b/tests/baselines/reference/importCallExpressionInAMD4.types
index e801b3835dab3..1f5c390e64b71 100644
--- a/tests/baselines/reference/importCallExpressionInAMD4.types
+++ b/tests/baselines/reference/importCallExpressionInAMD4.types
@@ -57,7 +57,7 @@ class C {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
 >                                                                                                                                                                                                                 : ^^^^^^^^^^^^^
 >this.myModule.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.myModule : Promise<typeof import("0")>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this : this
@@ -65,7 +65,7 @@ class C {
 >myModule : Promise<typeof import("0")>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("0")) => void
 >                                                       : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero : typeof import("0")
@@ -159,7 +159,7 @@ export class D {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
 >                                                                                                                                                                                                                 : ^^^^^^^^^^^^^
 >this.myModule.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.myModule : Promise<typeof import("0")>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this : this
@@ -167,7 +167,7 @@ export class D {
 >myModule : Promise<typeof import("0")>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("0")) => void
 >                                                       : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionInCJS1.types b/tests/baselines/reference/importCallExpressionInCJS1.types
index 4f6fc6e181d0a..938500485610f 100644
--- a/tests/baselines/reference/importCallExpressionInCJS1.types
+++ b/tests/baselines/reference/importCallExpressionInCJS1.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionInCJS3.types b/tests/baselines/reference/importCallExpressionInCJS3.types
index a0c32cd1c61bb..af654beb5e80b 100644
--- a/tests/baselines/reference/importCallExpressionInCJS3.types
+++ b/tests/baselines/reference/importCallExpressionInCJS3.types
@@ -24,11 +24,11 @@ function foo(x: Promise<any>) {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
 >                                                                        : ^^^^^^^^^^^^^
 >x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : Promise<any>
 >  : ^^^^^^^^^^^^
 >then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >                                                                : ^     ^^^^^^^^^^^^^^
 >value : any
diff --git a/tests/baselines/reference/importCallExpressionInCJS5.types b/tests/baselines/reference/importCallExpressionInCJS5.types
index 9fc19eeed40ce..3adfbc9c051c9 100644
--- a/tests/baselines/reference/importCallExpressionInCJS5.types
+++ b/tests/baselines/reference/importCallExpressionInCJS5.types
@@ -57,7 +57,7 @@ class C {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
 >                                                                                                                                                                                                                 : ^^^^^^^^^^^^^
 >this.myModule.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.myModule : Promise<typeof import("0")>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this : this
@@ -65,7 +65,7 @@ class C {
 >myModule : Promise<typeof import("0")>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("0")) => void
 >                                                       : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero : typeof import("0")
@@ -159,7 +159,7 @@ export class D {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
 >                                                                                                                                                                                                                 : ^^^^^^^^^^^^^
 >this.myModule.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.myModule : Promise<typeof import("0")>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this : this
@@ -167,7 +167,7 @@ export class D {
 >myModule : Promise<typeof import("0")>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("0")) => void
 >                                                       : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionInSystem1.types b/tests/baselines/reference/importCallExpressionInSystem1.types
index c65724d83565e..e41c50f7c1a24 100644
--- a/tests/baselines/reference/importCallExpressionInSystem1.types
+++ b/tests/baselines/reference/importCallExpressionInSystem1.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionInSystem2.types b/tests/baselines/reference/importCallExpressionInSystem2.types
index f88005277d119..2ffd403bec514 100644
--- a/tests/baselines/reference/importCallExpressionInSystem2.types
+++ b/tests/baselines/reference/importCallExpressionInSystem2.types
@@ -24,11 +24,11 @@ function foo(x: Promise<any>) {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
 >                                                                        : ^^^^^^^^^^^^^
 >x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : Promise<any>
 >  : ^^^^^^^^^^^^
 >then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >                                                                : ^     ^^^^^^^^^^^^^^
 >value : any
diff --git a/tests/baselines/reference/importCallExpressionInSystem4.types b/tests/baselines/reference/importCallExpressionInSystem4.types
index 407ed39affa69..cef7710895ee0 100644
--- a/tests/baselines/reference/importCallExpressionInSystem4.types
+++ b/tests/baselines/reference/importCallExpressionInSystem4.types
@@ -57,7 +57,7 @@ class C {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
 >                                                                                                                                                                                                                 : ^^^^^^^^^^^^^
 >this.myModule.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.myModule : Promise<typeof import("0")>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this : this
@@ -65,7 +65,7 @@ class C {
 >myModule : Promise<typeof import("0")>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("0")) => void
 >                                                       : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero : typeof import("0")
@@ -159,7 +159,7 @@ export class D {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
 >                                                                                                                                                                                                                 : ^^^^^^^^^^^^^
 >this.myModule.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.myModule : Promise<typeof import("0")>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this : this
@@ -167,7 +167,7 @@ export class D {
 >myModule : Promise<typeof import("0")>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("0")) => void
 >                                                       : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionInUMD1.types b/tests/baselines/reference/importCallExpressionInUMD1.types
index 6d33c5f867254..2cf45782d8273 100644
--- a/tests/baselines/reference/importCallExpressionInUMD1.types
+++ b/tests/baselines/reference/importCallExpressionInUMD1.types
@@ -26,11 +26,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();}) : Promise<string>
 >                                          : ^^^^^^^^^^^^^^^
 >p1.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<typeof import("0")>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();} : (zero: typeof import("0")) => string
 >                                 : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionInUMD2.types b/tests/baselines/reference/importCallExpressionInUMD2.types
index e8cb3a3139b73..55a9c46617fe4 100644
--- a/tests/baselines/reference/importCallExpressionInUMD2.types
+++ b/tests/baselines/reference/importCallExpressionInUMD2.types
@@ -24,11 +24,11 @@ function foo(x: Promise<any>) {
 >x.then(value => {        let b = new value.B();        b.print();    }) : Promise<void>
 >                                                                        : ^^^^^^^^^^^^^
 >x.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : Promise<any>
 >  : ^^^^^^^^^^^^
 >then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value => {        let b = new value.B();        b.print();    } : (value: any) => void
 >                                                                : ^     ^^^^^^^^^^^^^^
 >value : any
diff --git a/tests/baselines/reference/importCallExpressionInUMD4.types b/tests/baselines/reference/importCallExpressionInUMD4.types
index 7f99f995bc333..4cb77bf0414a0 100644
--- a/tests/baselines/reference/importCallExpressionInUMD4.types
+++ b/tests/baselines/reference/importCallExpressionInUMD4.types
@@ -57,7 +57,7 @@ class C {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
 >                                                                                                                                                                                                                 : ^^^^^^^^^^^^^
 >this.myModule.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.myModule : Promise<typeof import("0")>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this : this
@@ -65,7 +65,7 @@ class C {
 >myModule : Promise<typeof import("0")>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("0")) => void
 >                                                       : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero : typeof import("0")
@@ -159,7 +159,7 @@ export class D {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
 >                                                                                                                                                                                                                 : ^^^^^^^^^^^^^
 >this.myModule.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.myModule : Promise<typeof import("0")>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this : this
@@ -167,7 +167,7 @@ export class D {
 >myModule : Promise<typeof import("0")>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("0")) => void
 >                                                       : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types
index 9209b88178791..ad7279528d5e5 100644
--- a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types
+++ b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types
@@ -58,7 +58,7 @@ class C {
 >this.myModule.then(Zero => {            console.log(Zero.foo());        }, async err => {            console.log(err);            let one = await import("./1");            console.log(one.backup());        }) : Promise<void>
 >                                                                                                                                                                                                                 : ^^^^^^^^^^^^^
 >this.myModule.then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.myModule : Promise<typeof import("0")>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this : this
@@ -66,7 +66,7 @@ class C {
 >myModule : Promise<typeof import("0")>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = typeof import("0"), TResult2 = never>(onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero => {            console.log(Zero.foo());        } : (Zero: typeof import("0")) => void
 >                                                       : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Zero : typeof import("0")
diff --git a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
index b120c828041cb..2cd909131f93d 100644
--- a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
+++ b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
@@ -110,11 +110,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();  // ok, zero is any}) : Promise<any>
 >                                                              : ^^^^^^^^^^^^
 >p1.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<any>
 >   : ^^^^^^^^^^^^
 >then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();  // ok, zero is any} : (zero: any) => any
 >                                                     : ^    ^^^^^^^^^^^^^
 >zero : any
diff --git a/tests/baselines/reference/importCallExpressionShouldNotGetParen.types b/tests/baselines/reference/importCallExpressionShouldNotGetParen.types
index 021f995fc31bc..f99d1d3111e6a 100644
--- a/tests/baselines/reference/importCallExpressionShouldNotGetParen.types
+++ b/tests/baselines/reference/importCallExpressionShouldNotGetParen.types
@@ -11,7 +11,7 @@ import(`./locales/${localeName}.js`).then(bar => {
 >import(`./locales/${localeName}.js`).then(bar => {    let x = bar;}) : Promise<void>
 >                                                                     : ^^^^^^^^^^^^^
 >import(`./locales/${localeName}.js`).then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                                          : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                                          : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >import(`./locales/${localeName}.js`) : Promise<any>
 >                                     : ^^^^^^^^^^^^
 >`./locales/${localeName}.js` : "./locales/zh-CN.js"
@@ -19,7 +19,7 @@ import(`./locales/${localeName}.js`).then(bar => {
 >localeName : "zh-CN"
 >           : ^^^^^^^
 >then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >bar => {    let x = bar;} : (bar: any) => void
 >                          : ^   ^^^^^^^^^^^^^^
 >bar : any
@@ -34,7 +34,7 @@ import("./locales/" + localeName + ".js").then(bar => {
 >import("./locales/" + localeName + ".js").then(bar => {    let x = bar;}) : Promise<void>
 >                                                                          : ^^^^^^^^^^^^^
 >import("./locales/" + localeName + ".js").then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                                               : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                                               : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >import("./locales/" + localeName + ".js") : Promise<any>
 >                                          : ^^^^^^^^^^^^
 >"./locales/" + localeName + ".js" : string
@@ -48,7 +48,7 @@ import("./locales/" + localeName + ".js").then(bar => {
 >".js" : ".js"
 >      : ^^^^^
 >then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >bar => {    let x = bar;} : (bar: any) => void
 >                          : ^   ^^^^^^^^^^^^^^
 >bar : any
diff --git a/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types
index 33b7952719262..0fe8ed184071f 100644
--- a/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types
+++ b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types
@@ -48,11 +48,11 @@ p1.then(zero => {
 >p1.then(zero => {    return zero.foo();  // ok, zero is any}) : Promise<any>
 >                                                              : ^^^^^^^^^^^^
 >p1.then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->        : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>        : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p1 : Promise<any>
 >   : ^^^^^^^^^^^^
 >then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >zero => {    return zero.foo();  // ok, zero is any} : (zero: any) => any
 >                                                     : ^    ^^^^^^^^^^^^^
 >zero : any
diff --git a/tests/baselines/reference/indexAt(target=es2022).types b/tests/baselines/reference/indexAt(target=es2022).types
index d9ed90c20579c..2201919b20620 100644
--- a/tests/baselines/reference/indexAt(target=es2022).types
+++ b/tests/baselines/reference/indexAt(target=es2022).types
@@ -4,14 +4,14 @@
 [0].at(0);
 >[0].at(0) : number
 >          : ^^^^^^
->[0].at : (index: number) => number | undefined
->       : ^     ^^      ^^^^^^^^^^^            
+>[0].at : (index: number) => number
+>       : ^     ^^      ^^^^^^^^^^^
 >[0] : number[]
 >    : ^^^^^^^^
 >0 : 0
 >  : ^
->at : (index: number) => number | undefined
->   : ^     ^^      ^^^^^^^^^^^            
+>at : (index: number) => number
+>   : ^     ^^      ^^^^^^^^^^^
 >0 : 0
 >  : ^
 
diff --git a/tests/baselines/reference/indexAt(target=esnext).types b/tests/baselines/reference/indexAt(target=esnext).types
index d9ed90c20579c..2201919b20620 100644
--- a/tests/baselines/reference/indexAt(target=esnext).types
+++ b/tests/baselines/reference/indexAt(target=esnext).types
@@ -4,14 +4,14 @@
 [0].at(0);
 >[0].at(0) : number
 >          : ^^^^^^
->[0].at : (index: number) => number | undefined
->       : ^     ^^      ^^^^^^^^^^^            
+>[0].at : (index: number) => number
+>       : ^     ^^      ^^^^^^^^^^^
 >[0] : number[]
 >    : ^^^^^^^^
 >0 : 0
 >  : ^
->at : (index: number) => number | undefined
->   : ^     ^^      ^^^^^^^^^^^            
+>at : (index: number) => number
+>   : ^     ^^      ^^^^^^^^^^^
 >0 : 0
 >  : ^
 
diff --git a/tests/baselines/reference/indexedAccessTypeConstraints.types b/tests/baselines/reference/indexedAccessTypeConstraints.types
index a3ea8680c614c..17b5fb66dd175 100644
--- a/tests/baselines/reference/indexedAccessTypeConstraints.types
+++ b/tests/baselines/reference/indexedAccessTypeConstraints.types
@@ -61,11 +61,11 @@ export class Foo<C> extends Parent<IData<C>> {
 >this.getData() : Data<IData<C>>
 >               : ^^^^^^^^^^^^^^
 >this.getData : () => Data<IData<C>>
->             : ^^^^^^     ^^^^^^^^ 
+>             : ^^^^^^^^^^^^^^^^^^^^
 >this : this
 >     : ^^^^
 >getData : () => Data<IData<C>>
->        : ^^^^^^     ^^^^^^^^ 
+>        : ^^^^^^^^^^^^^^^^^^^^
 >get : <K extends "content">(prop: K) => IData<C>[K]
 >    : ^ ^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^
 >'content' : "content"
@@ -91,11 +91,11 @@ export class Bar<C, T extends IData<C>> extends Parent<T> {
 >this.getData() : Data<T>
 >               : ^^^^^^^
 >this.getData : () => Data<T>
->             : ^^^^^^     ^ 
+>             : ^^^^^^^^^^^^^
 >this : this
 >     : ^^^^
 >getData : () => Data<T>
->        : ^^^^^^     ^ 
+>        : ^^^^^^^^^^^^^
 >get : <K extends keyof T>(prop: K) => T[K]
 >    : ^ ^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^
 >'content' : "content"
diff --git a/tests/baselines/reference/indirectGlobalSymbolPartOfObjectType.types b/tests/baselines/reference/indirectGlobalSymbolPartOfObjectType.types
index 8712cb2a3e9df..6003f038d368e 100644
--- a/tests/baselines/reference/indirectGlobalSymbolPartOfObjectType.types
+++ b/tests/baselines/reference/indirectGlobalSymbolPartOfObjectType.types
@@ -14,7 +14,7 @@ const Symbol = globalThis.Symbol;
 
 [][Symbol.iterator];
 >[][Symbol.iterator] : () => IterableIterator<undefined>
->                    : ^^^^^^                 ^^^^^^^^^ 
+>                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 >Symbol.iterator : unique symbol
diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes1.types b/tests/baselines/reference/inferFromGenericFunctionReturnTypes1.types
index d5c555a510997..b8a1afe03d68e 100644
--- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes1.types
+++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes1.types
@@ -333,21 +333,21 @@ testSet.transform(
 >testSet.transform(  compose(    filter(x => x % 1 === 0),    map(x => x + x),    map(x => x + '!!!'),    map(x => x.toUpperCase())  )) : SetOf<string>
 >                                                                                                                                       : ^^^^^^^^^^^^^
 >testSet.transform : <B>(transformer: (a: SetOf<number>) => SetOf<B>) => SetOf<B>
->                  : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^      ^ ^^^^^      ^ 
+>                  : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >testSet : SetOf<number>
 >        : ^^^^^^^^^^^^^
 >transform : <B>(transformer: (a: SetOf<number>) => SetOf<B>) => SetOf<B>
->          : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^      ^ ^^^^^      ^ 
+>          : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
   compose(
 >compose(    filter(x => x % 1 === 0),    map(x => x + x),    map(x => x + '!!!'),    map(x => x.toUpperCase())  ) : (x: SetOf<number>) => SetOf<string>
->                                                                                                                  : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                                                                                                                  : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >compose : <A, B, C, D, E>(fnA: (a: SetOf<A>) => SetOf<B>, fnB: (b: SetOf<B>) => SetOf<C>, fnC: (c: SetOf<C>) => SetOf<D>, fnD: (c: SetOf<D>) => SetOf<E>) => (x: SetOf<A>) => SetOf<E>
 >        : ^ ^^ ^^ ^^ ^^ ^^   ^^                         ^^   ^^                         ^^   ^^                         ^^   ^^                         ^^^^^                         
 
     filter(x => x % 1 === 0),
 >filter(x => x % 1 === 0) : (s: SetOf<number>) => SetOf<number>
->                         : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                         : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >filter : <A>(predicate: (a: A) => boolean) => (s: SetOf<A>) => SetOf<A>
 >       : ^ ^^         ^^                 ^^^^^                         
 >x => x % 1 === 0 : (x: number) => boolean
@@ -367,7 +367,7 @@ testSet.transform(
 
     map(x => x + x),
 >map(x => x + x) : (s: SetOf<number>) => SetOf<number>
->                : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <A, B>(fn: (a: A) => B) => (s: SetOf<A>) => SetOf<B>
 >    : ^ ^^ ^^  ^^           ^^^^^                         
 >x => x + x : (x: number) => number
@@ -383,7 +383,7 @@ testSet.transform(
 
     map(x => x + '!!!'),
 >map(x => x + '!!!') : (s: SetOf<number>) => SetOf<string>
->                    : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                    : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <A, B>(fn: (a: A) => B) => (s: SetOf<A>) => SetOf<B>
 >    : ^ ^^ ^^  ^^           ^^^^^                         
 >x => x + '!!!' : (x: number) => string
@@ -399,7 +399,7 @@ testSet.transform(
 
     map(x => x.toUpperCase())
 >map(x => x.toUpperCase()) : (s: SetOf<string>) => SetOf<string>
->                          : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                          : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <A, B>(fn: (a: A) => B) => (s: SetOf<A>) => SetOf<B>
 >    : ^ ^^ ^^  ^^           ^^^^^                         
 >x => x.toUpperCase() : (x: string) => string
@@ -422,21 +422,21 @@ testSet.transform(
 >testSet.transform(  compose(    filter(x => x % 1 === 0),    map(x => x + x),    map(x => 123),  // Whoops a bug    map(x => x.toUpperCase()) // causes an error!  )) : SetOf<any>
 >                                                                                                                                                                      : ^^^^^^^^^^
 >testSet.transform : <B>(transformer: (a: SetOf<number>) => SetOf<B>) => SetOf<B>
->                  : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^      ^ ^^^^^      ^ 
+>                  : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >testSet : SetOf<number>
 >        : ^^^^^^^^^^^^^
 >transform : <B>(transformer: (a: SetOf<number>) => SetOf<B>) => SetOf<B>
->          : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^      ^ ^^^^^      ^ 
+>          : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
   compose(
 >compose(    filter(x => x % 1 === 0),    map(x => x + x),    map(x => 123),  // Whoops a bug    map(x => x.toUpperCase()) // causes an error!  ) : (x: SetOf<number>) => SetOf<any>
->                                                                                                                                                 : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^ 
+>                                                                                                                                                 : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >compose : <A, B, C, D, E>(fnA: (a: SetOf<A>) => SetOf<B>, fnB: (b: SetOf<B>) => SetOf<C>, fnC: (c: SetOf<C>) => SetOf<D>, fnD: (c: SetOf<D>) => SetOf<E>) => (x: SetOf<A>) => SetOf<E>
 >        : ^ ^^ ^^ ^^ ^^ ^^   ^^                         ^^   ^^                         ^^   ^^                         ^^   ^^                         ^^^^^                         
 
     filter(x => x % 1 === 0),
 >filter(x => x % 1 === 0) : (s: SetOf<number>) => SetOf<number>
->                         : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                         : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >filter : <A>(predicate: (a: A) => boolean) => (s: SetOf<A>) => SetOf<A>
 >       : ^ ^^         ^^                 ^^^^^                         
 >x => x % 1 === 0 : (x: number) => boolean
@@ -456,7 +456,7 @@ testSet.transform(
 
     map(x => x + x),
 >map(x => x + x) : (s: SetOf<number>) => SetOf<number>
->                : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <A, B>(fn: (a: A) => B) => (s: SetOf<A>) => SetOf<B>
 >    : ^ ^^ ^^  ^^           ^^^^^                         
 >x => x + x : (x: number) => number
@@ -472,7 +472,7 @@ testSet.transform(
 
     map(x => 123),  // Whoops a bug
 >map(x => 123) : (s: SetOf<number>) => SetOf<number>
->              : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>              : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <A, B>(fn: (a: A) => B) => (s: SetOf<A>) => SetOf<B>
 >    : ^ ^^ ^^  ^^           ^^^^^                         
 >x => 123 : (x: number) => number
@@ -484,7 +484,7 @@ testSet.transform(
 
     map(x => x.toUpperCase()) // causes an error!
 >map(x => x.toUpperCase()) : (s: SetOf<number>) => SetOf<any>
->                          : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^ 
+>                          : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <A, B>(fn: (a: A) => B) => (s: SetOf<A>) => SetOf<B>
 >    : ^ ^^ ^^  ^^           ^^^^^                         
 >x => x.toUpperCase() : (x: number) => any
diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes2.types b/tests/baselines/reference/inferFromGenericFunctionReturnTypes2.types
index 4363116ff2dc4..0524f0f522e81 100644
--- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes2.types
+++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes2.types
@@ -155,7 +155,7 @@ let a1 = ["a", "b"].map(s => s.length);
 >["a", "b"].map(s => s.length) : number[]
 >                              : ^^^^^^^^
 >["a", "b"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >["a", "b"] : string[]
 >           : ^^^^^^^^
 >"a" : "a"
@@ -163,7 +163,7 @@ let a1 = ["a", "b"].map(s => s.length);
 >"b" : "b"
 >    : ^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >s => s.length : (s: string) => number
 >              : ^ ^^^^^^^^^^^^^^^^^^^
 >s : string
@@ -181,7 +181,7 @@ let a2 = ["a", "b"].map(wrap(s => s.length));
 >["a", "b"].map(wrap(s => s.length)) : number[]
 >                                    : ^^^^^^^^
 >["a", "b"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >["a", "b"] : string[]
 >           : ^^^^^^^^
 >"a" : "a"
@@ -189,7 +189,7 @@ let a2 = ["a", "b"].map(wrap(s => s.length));
 >"b" : "b"
 >    : ^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >wrap(s => s.length) : Mapper<string, number>
 >                    : ^^^^^^^^^^^^^^^^^^^^^^
 >wrap : <T, U>(cb: Mapper<T, U>) => Mapper<T, U>
@@ -211,7 +211,7 @@ let a3 = ["a", "b"].map(wrap(arrayize(s => s.length)));
 >["a", "b"].map(wrap(arrayize(s => s.length))) : number[][]
 >                                              : ^^^^^^^^^^
 >["a", "b"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >["a", "b"] : string[]
 >           : ^^^^^^^^
 >"a" : "a"
@@ -219,7 +219,7 @@ let a3 = ["a", "b"].map(wrap(arrayize(s => s.length)));
 >"b" : "b"
 >    : ^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >wrap(arrayize(s => s.length)) : Mapper<string, number[]>
 >                              : ^^^^^^^^^^^^^^^^^^^^^^^^
 >wrap : <T, U>(cb: Mapper<T, U>) => Mapper<T, U>
@@ -245,7 +245,7 @@ let a4 = ["a", "b"].map(combine(wrap(s => s.length), wrap(n => n > 10)));
 >["a", "b"].map(combine(wrap(s => s.length), wrap(n => n > 10))) : boolean[]
 >                                                                : ^^^^^^^^^
 >["a", "b"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >["a", "b"] : string[]
 >           : ^^^^^^^^
 >"a" : "a"
@@ -253,7 +253,7 @@ let a4 = ["a", "b"].map(combine(wrap(s => s.length), wrap(n => n > 10)));
 >"b" : "b"
 >    : ^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >combine(wrap(s => s.length), wrap(n => n > 10)) : (x: string) => boolean
 >                                                : ^ ^^^^^^^^^^^^^^^^^^^^
 >combine : <A, B, C>(f: (x: A) => B, g: (x: B) => C) => (x: A) => C
@@ -293,7 +293,7 @@ let a5 = ["a", "b"].map(combine(identity, wrap(s => s.length)));
 >["a", "b"].map(combine(identity, wrap(s => s.length))) : number[]
 >                                                       : ^^^^^^^^
 >["a", "b"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >["a", "b"] : string[]
 >           : ^^^^^^^^
 >"a" : "a"
@@ -301,7 +301,7 @@ let a5 = ["a", "b"].map(combine(identity, wrap(s => s.length)));
 >"b" : "b"
 >    : ^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >combine(identity, wrap(s => s.length)) : (x: string) => number
 >                                       : ^ ^^^^^^^^^^^^^^^^^^^
 >combine : <A, B, C>(f: (x: A) => B, g: (x: B) => C) => (x: A) => C
@@ -329,7 +329,7 @@ let a6 = ["a", "b"].map(combine(wrap(s => s.length), identity));
 >["a", "b"].map(combine(wrap(s => s.length), identity)) : number[]
 >                                                       : ^^^^^^^^
 >["a", "b"].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >["a", "b"] : string[]
 >           : ^^^^^^^^
 >"a" : "a"
@@ -337,7 +337,7 @@ let a6 = ["a", "b"].map(combine(wrap(s => s.length), identity));
 >"b" : "b"
 >    : ^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >combine(wrap(s => s.length), identity) : (x: string) => number
 >                                       : ^ ^^^^^^^^^^^^^^^^^^^
 >combine : <A, B, C>(f: (x: A) => B, g: (x: B) => C) => (x: A) => C
@@ -691,21 +691,21 @@ const t1 = testSet.transform(
 >testSet.transform(  compose(    filter(x => x % 1 === 0),    map(x => x + x),    map(x => x + '!!!'),    map(x => x.toUpperCase())  )) : SetOf<string>
 >                                                                                                                                       : ^^^^^^^^^^^^^
 >testSet.transform : <B>(transformer: (a: SetOf<number>) => SetOf<B>) => SetOf<B>
->                  : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^      ^ ^^^^^      ^ 
+>                  : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >testSet : SetOf<number>
 >        : ^^^^^^^^^^^^^
 >transform : <B>(transformer: (a: SetOf<number>) => SetOf<B>) => SetOf<B>
->          : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^      ^ ^^^^^      ^ 
+>          : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
   compose(
 >compose(    filter(x => x % 1 === 0),    map(x => x + x),    map(x => x + '!!!'),    map(x => x.toUpperCase())  ) : (x: SetOf<number>) => SetOf<string>
->                                                                                                                  : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                                                                                                                  : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >compose : <A, B, C, D, E>(fnA: (a: SetOf<A>) => SetOf<B>, fnB: (b: SetOf<B>) => SetOf<C>, fnC: (c: SetOf<C>) => SetOf<D>, fnD: (c: SetOf<D>) => SetOf<E>) => (x: SetOf<A>) => SetOf<E>
 >        : ^ ^^ ^^ ^^ ^^ ^^   ^^                         ^^   ^^                         ^^   ^^                         ^^   ^^                         ^^^^^                         
 
     filter(x => x % 1 === 0),
 >filter(x => x % 1 === 0) : (s: SetOf<number>) => SetOf<number>
->                         : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                         : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >filter : <A>(predicate: (a: A) => boolean) => (s: SetOf<A>) => SetOf<A>
 >       : ^ ^^         ^^                 ^^^^^                         
 >x => x % 1 === 0 : (x: number) => boolean
@@ -725,7 +725,7 @@ const t1 = testSet.transform(
 
     map(x => x + x),
 >map(x => x + x) : (s: SetOf<number>) => SetOf<number>
->                : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <A, B>(fn: (a: A) => B) => (s: SetOf<A>) => SetOf<B>
 >    : ^ ^^ ^^  ^^           ^^^^^                         
 >x => x + x : (x: number) => number
@@ -741,7 +741,7 @@ const t1 = testSet.transform(
 
     map(x => x + '!!!'),
 >map(x => x + '!!!') : (s: SetOf<number>) => SetOf<string>
->                    : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                    : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <A, B>(fn: (a: A) => B) => (s: SetOf<A>) => SetOf<B>
 >    : ^ ^^ ^^  ^^           ^^^^^                         
 >x => x + '!!!' : (x: number) => string
@@ -757,7 +757,7 @@ const t1 = testSet.transform(
 
     map(x => x.toUpperCase())
 >map(x => x.toUpperCase()) : (s: SetOf<string>) => SetOf<string>
->                          : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                          : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <A, B>(fn: (a: A) => B) => (s: SetOf<A>) => SetOf<B>
 >    : ^ ^^ ^^  ^^           ^^^^^                         
 >x => x.toUpperCase() : (x: string) => string
@@ -788,21 +788,21 @@ const t2 = testSet.transform(
 >testSet.transform(  compose(    filter(x => x % 1 === 0),    identity,    map(x => x + '!!!'),    map(x => x.toUpperCase())  )) : SetOf<string>
 >                                                                                                                                : ^^^^^^^^^^^^^
 >testSet.transform : <B>(transformer: (a: SetOf<number>) => SetOf<B>) => SetOf<B>
->                  : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^      ^ ^^^^^      ^ 
+>                  : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >testSet : SetOf<number>
 >        : ^^^^^^^^^^^^^
 >transform : <B>(transformer: (a: SetOf<number>) => SetOf<B>) => SetOf<B>
->          : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^      ^ ^^^^^      ^ 
+>          : ^ ^^           ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
   compose(
 >compose(    filter(x => x % 1 === 0),    identity,    map(x => x + '!!!'),    map(x => x.toUpperCase())  ) : (x: SetOf<number>) => SetOf<string>
->                                                                                                           : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                                                                                                           : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >compose : <A, B, C, D, E>(fnA: (a: SetOf<A>) => SetOf<B>, fnB: (b: SetOf<B>) => SetOf<C>, fnC: (c: SetOf<C>) => SetOf<D>, fnD: (c: SetOf<D>) => SetOf<E>) => (x: SetOf<A>) => SetOf<E>
 >        : ^ ^^ ^^ ^^ ^^ ^^   ^^                         ^^   ^^                         ^^   ^^                         ^^   ^^                         ^^^^^                         
 
     filter(x => x % 1 === 0),
 >filter(x => x % 1 === 0) : (s: SetOf<number>) => SetOf<number>
->                         : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                         : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >filter : <A>(predicate: (a: A) => boolean) => (s: SetOf<A>) => SetOf<A>
 >       : ^ ^^         ^^                 ^^^^^                         
 >x => x % 1 === 0 : (x: number) => boolean
@@ -826,7 +826,7 @@ const t2 = testSet.transform(
 
     map(x => x + '!!!'),
 >map(x => x + '!!!') : (s: SetOf<number>) => SetOf<string>
->                    : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                    : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <A, B>(fn: (a: A) => B) => (s: SetOf<A>) => SetOf<B>
 >    : ^ ^^ ^^  ^^           ^^^^^                         
 >x => x + '!!!' : (x: number) => string
@@ -842,7 +842,7 @@ const t2 = testSet.transform(
 
     map(x => x.toUpperCase())
 >map(x => x.toUpperCase()) : (s: SetOf<string>) => SetOf<string>
->                          : ^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^ 
+>                          : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <A, B>(fn: (a: A) => B) => (s: SetOf<A>) => SetOf<B>
 >    : ^ ^^ ^^  ^^           ^^^^^                         
 >x => x.toUpperCase() : (x: string) => string
diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
index d4170b334be7c..c4a3eace14466 100644
--- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
+++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
@@ -163,7 +163,7 @@ a = [1, 2, 3, 4, 5].map(v => ({ type: 'folder' }));
 >[1, 2, 3, 4, 5].map(v => ({ type: 'folder' })) : { type: "folder"; }[]
 >                                               : ^^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3, 4, 5].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->                    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1, 2, 3, 4, 5] : number[]
 >                : ^^^^^^^^
 >1 : 1
@@ -177,7 +177,7 @@ a = [1, 2, 3, 4, 5].map(v => ({ type: 'folder' }));
 >5 : 5
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >v => ({ type: 'folder' }) : (v: number) => { type: "folder"; }
 >                          : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >v : number
@@ -211,11 +211,11 @@ let mappedArr: Array<[number, number]> = arr.map(([x, y]) => {
 >arr.map(([x, y]) => {    return [x, y];}) : [number, number][]
 >                                          : ^^^^^^^^^^^^^^^^^^
 >arr.map : <U>(callbackfn: (value: [number, number], index: number, array: [number, number][]) => U, thisArg?: any) => U[]
->        : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>        : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >arr : [number, number][]
 >    : ^^^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: [number, number], index: number, array: [number, number][]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >([x, y]) => {    return [x, y];} : ([x, y]: [number, number]) => [number, number]
 >                                 : ^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
@@ -300,11 +300,11 @@ function bug(): Diagnostic[] {
 >values.map((value) => {		return {			severity: DiagnosticSeverity.Error,			message: 'message'		}	}) : { severity: 1; message: string; }[]
 >                                                                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >values.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
->           : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>           : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >values : any[]
 >       : ^^^^^
 >map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(value) => {		return {			severity: DiagnosticSeverity.Error,			message: 'message'		}	} : (value: any) => { severity: 1; message: string; }
 >                                                                                       : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value : any
@@ -349,7 +349,7 @@ function objectToMap(obj: any) {
 >Object.keys(obj).map(key => [key, obj[key]]) : [string, any][]
 >                                             : ^^^^^^^^^^^^^^^
 >Object.keys(obj).map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->                     : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                     : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >Object.keys(obj) : string[]
 >                 : ^^^^^^^^
 >Object.keys : { (o: object): string[]; (o: {}): string[]; }
@@ -361,7 +361,7 @@ function objectToMap(obj: any) {
 >obj : any
 >    : ^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >key => [key, obj[key]] : (key: string) => [string, any]
 >                       : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >key : string
@@ -407,13 +407,13 @@ function createPerson(): Person {
 >[1].map(() => ({      __typename: 'PhoneNumber'    })) : { __typename: "PhoneNumber"; }[]
 >                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[1].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->        : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>        : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1] : number[]
 >    : ^^^^^^^^
 >1 : 1
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >() => ({      __typename: 'PhoneNumber'    }) : () => { __typename: "PhoneNumber"; }
 >                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >({      __typename: 'PhoneNumber'    }) : { __typename: "PhoneNumber"; }
@@ -555,7 +555,7 @@ const a3: I[] = ['a', 'b'].map(name => {
 >['a', 'b'].map(name => {    return {        code: 'mapped',        name,    }}) : { code: "mapped"; name: string; }[]
 >                                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >['a', 'b'].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>               : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >['a', 'b'] : string[]
 >           : ^^^^^^^^
 >'a' : "a"
@@ -563,7 +563,7 @@ const a3: I[] = ['a', 'b'].map(name => {
 >'b' : "b"
 >    : ^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >name => {    return {        code: 'mapped',        name,    }} : (name: string) => { code: "mapped"; name: string; }
 >                                                                : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >name : string
diff --git a/tests/baselines/reference/inferTypePredicates.types b/tests/baselines/reference/inferTypePredicates.types
index 20eaa4a583148..e604e593a0e2f 100644
--- a/tests/baselines/reference/inferTypePredicates.types
+++ b/tests/baselines/reference/inferTypePredicates.types
@@ -23,11 +23,11 @@ const filteredNumsTruthy: number[] = numsOrNull.filter(x => !!x);  // should err
 >numsOrNull.filter(x => !!x) : (number | null)[]
 >                            : ^^^^^^^^^^^^^^^^^
 >numsOrNull.filter : { <S extends number | null>(predicate: (value: number | null, index: number, array: (number | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: number | null, index: number, array: (number | null)[]) => unknown, thisArg?: any): (number | null)[]; }
->                  : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^  ^^^
+>                  : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >numsOrNull : (number | null)[]
 >           : ^^^^^^^^^^^^^^^^^
 >filter : { <S extends number | null>(predicate: (value: number | null, index: number, array: (number | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: number | null, index: number, array: (number | null)[]) => unknown, thisArg?: any): (number | null)[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >x => !!x : (x: number | null) => boolean
 >         : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number | null
@@ -45,11 +45,11 @@ const filteredNumsNonNullish: number[] = numsOrNull.filter(x => x !== null);  //
 >numsOrNull.filter(x => x !== null) : number[]
 >                                   : ^^^^^^^^
 >numsOrNull.filter : { <S extends number | null>(predicate: (value: number | null, index: number, array: (number | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: number | null, index: number, array: (number | null)[]) => unknown, thisArg?: any): (number | null)[]; }
->                  : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^  ^^^
+>                  : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >numsOrNull : (number | null)[]
 >           : ^^^^^^^^^^^^^^^^^
 >filter : { <S extends number | null>(predicate: (value: number | null, index: number, array: (number | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: number | null, index: number, array: (number | null)[]) => unknown, thisArg?: any): (number | null)[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >x => x !== null : (x: number | null) => x is number
 >                : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number | null
@@ -67,11 +67,11 @@ const evenSquaresInline: number[] =  // should error
 >[1, 2, 3, 4]        .map(x => x % 2 === 0 ? x * x : null)        .filter(x => !!x) : (number | null)[]
 >                                                                                   : ^^^^^^^^^^^^^^^^^
 >[1, 2, 3, 4]        .map(x => x % 2 === 0 ? x * x : null)        .filter : { <S extends number | null>(predicate: (value: number | null, index: number, array: (number | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: number | null, index: number, array: (number | null)[]) => unknown, thisArg?: any): (number | null)[]; }
->                                                                         : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^  ^^^
+>                                                                         : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3, 4]        .map(x => x % 2 === 0 ? x * x : null) : (number | null)[]
 >                                                          : ^^^^^^^^^^^^^^^^^
 >[1, 2, 3, 4]        .map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->                         : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                         : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1, 2, 3, 4] : number[]
 >             : ^^^^^^^^
 >1 : 1
@@ -85,7 +85,7 @@ const evenSquaresInline: number[] =  // should error
 
         .map(x => x % 2 === 0 ? x * x : null)
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >x => x % 2 === 0 ? x * x : null : (x: number) => number | null
 >                                : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
@@ -111,7 +111,7 @@ const evenSquaresInline: number[] =  // should error
 
         .filter(x => !!x); // tests truthiness, not non-nullishness
 >filter : { <S extends number | null>(predicate: (value: number | null, index: number, array: (number | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: number | null, index: number, array: (number | null)[]) => unknown, thisArg?: any): (number | null)[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >x => !!x : (x: number | null) => boolean
 >         : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number | null
@@ -145,11 +145,11 @@ const evenSquares: number[] =  // should error
 >[1, 2, 3, 4]    .map(x => x % 2 === 0 ? x * x : null)      .filter(isTruthy) : (number | null)[]
 >                                                                             : ^^^^^^^^^^^^^^^^^
 >[1, 2, 3, 4]    .map(x => x % 2 === 0 ? x * x : null)      .filter : { <S extends number | null>(predicate: (value: number | null, index: number, array: (number | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: number | null, index: number, array: (number | null)[]) => unknown, thisArg?: any): (number | null)[]; }
->                                                                   : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^  ^^^
+>                                                                   : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3, 4]    .map(x => x % 2 === 0 ? x * x : null) : (number | null)[]
 >                                                      : ^^^^^^^^^^^^^^^^^
 >[1, 2, 3, 4]    .map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->                     : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                     : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1, 2, 3, 4] : number[]
 >             : ^^^^^^^^
 >1 : 1
@@ -163,7 +163,7 @@ const evenSquares: number[] =  // should error
 
     .map(x => x % 2 === 0 ? x * x : null)
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >x => x % 2 === 0 ? x * x : null : (x: number) => number | null
 >                                : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
@@ -189,7 +189,7 @@ const evenSquares: number[] =  // should error
 
       .filter(isTruthy);
 >filter : { <S extends number | null>(predicate: (value: number | null, index: number, array: (number | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: number | null, index: number, array: (number | null)[]) => unknown, thisArg?: any): (number | null)[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >isTruthy : (x: number | null) => boolean
 >         : ^ ^^             ^^^^^^^^^^^^
 
@@ -201,11 +201,11 @@ const evenSquaresNonNull: number[] =  // should ok
 >[1, 2, 3, 4]    .map(x => x % 2 === 0 ? x * x : null)    .filter(x => x !== null) : number[]
 >                                                                                  : ^^^^^^^^
 >[1, 2, 3, 4]    .map(x => x % 2 === 0 ? x * x : null)    .filter : { <S extends number | null>(predicate: (value: number | null, index: number, array: (number | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: number | null, index: number, array: (number | null)[]) => unknown, thisArg?: any): (number | null)[]; }
->                                                                 : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^  ^^^
+>                                                                 : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3, 4]    .map(x => x % 2 === 0 ? x * x : null) : (number | null)[]
 >                                                      : ^^^^^^^^^^^^^^^^^
 >[1, 2, 3, 4]    .map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->                     : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                     : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1, 2, 3, 4] : number[]
 >             : ^^^^^^^^
 >1 : 1
@@ -219,7 +219,7 @@ const evenSquaresNonNull: number[] =  // should ok
 
     .map(x => x % 2 === 0 ? x * x : null)
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >x => x % 2 === 0 ? x * x : null : (x: number) => number | null
 >                                : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
@@ -245,7 +245,7 @@ const evenSquaresNonNull: number[] =  // should ok
 
     .filter(x => x !== null);
 >filter : { <S extends number | null>(predicate: (value: number | null, index: number, array: (number | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: number | null, index: number, array: (number | null)[]) => unknown, thisArg?: any): (number | null)[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >x => x !== null : (x: number | null) => x is number
 >                : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number | null
@@ -357,21 +357,21 @@ const result = myArray
 >myArray  .map((arr) => arr.list)  .filter((arr) => arr && arr.length)  .map((arr) => arr // should error    .filter((obj) => obj && obj.data)    .map(obj => JSON.parse(obj.data))  // should error  ) : any[][]
 >                                                                                                                                                                                                       : ^^^^^^^
 >myArray  .map((arr) => arr.list)  .filter((arr) => arr && arr.length)  .map : <U>(callbackfn: (value: MyObj[] | undefined, index: number, array: (MyObj[] | undefined)[]) => U, thisArg?: any) => U[]
->                                                                            : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                                                                            : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >myArray  .map((arr) => arr.list)  .filter((arr) => arr && arr.length) : (MyObj[] | undefined)[]
 >                                                                      : ^^^^^^^^^^^^^^^^^^^^^^^
 >myArray  .map((arr) => arr.list)  .filter : { <S extends MyObj[] | undefined>(predicate: (value: MyObj[] | undefined, index: number, array: (MyObj[] | undefined)[]) => value is S, thisArg?: any): S[]; (predicate: (value: MyObj[] | undefined, index: number, array: (MyObj[] | undefined)[]) => unknown, thisArg?: any): (MyObj[] | undefined)[]; }
->                                          : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>                                          : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >myArray  .map((arr) => arr.list) : (MyObj[] | undefined)[]
 >                                 : ^^^^^^^^^^^^^^^^^^^^^^^
 >myArray  .map : <U>(callbackfn: (value: { list?: MyObj[]; }, index: number, array: { list?: MyObj[]; }[]) => U, thisArg?: any) => U[]
->              : ^ ^^          ^^^     ^^^^^^^^^^^       ^^^^^     ^^      ^^     ^^^^^^^^^^^       ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>              : ^ ^^          ^^^     ^^^^^^^^^^^       ^^^^^     ^^      ^^     ^^^^^^^^^^^       ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >myArray : MyArray
 >        : ^^^^^^^
 
   .map((arr) => arr.list)
 >map : <U>(callbackfn: (value: { list?: MyObj[]; }, index: number, array: { list?: MyObj[]; }[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^       ^^^^^     ^^      ^^     ^^^^^^^^^^^       ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^       ^^^^^     ^^      ^^     ^^^^^^^^^^^       ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(arr) => arr.list : (arr: { list?: MyObj[]; }) => MyObj[] | undefined
 >                  : ^   ^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >arr : { list?: MyObj[]; }
@@ -385,7 +385,7 @@ const result = myArray
 
   .filter((arr) => arr && arr.length)
 >filter : { <S extends MyObj[] | undefined>(predicate: (value: MyObj[] | undefined, index: number, array: (MyObj[] | undefined)[]) => value is S, thisArg?: any): S[]; (predicate: (value: MyObj[] | undefined, index: number, array: (MyObj[] | undefined)[]) => unknown, thisArg?: any): (MyObj[] | undefined)[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(arr) => arr && arr.length : (arr: MyObj[] | undefined) => number | undefined
 >                           : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >arr : MyObj[] | undefined
@@ -403,7 +403,7 @@ const result = myArray
 
   .map((arr) => arr // should error
 >map : <U>(callbackfn: (value: MyObj[] | undefined, index: number, array: (MyObj[] | undefined)[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(arr) => arr // should error    .filter((obj) => obj && obj.data)    .map(obj => JSON.parse(obj.data)) : (arr: MyObj[] | undefined) => any[]
 >                                                                                                       : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >arr : MyObj[] | undefined
@@ -411,17 +411,17 @@ const result = myArray
 >arr // should error    .filter((obj) => obj && obj.data)    .map(obj => JSON.parse(obj.data)) : any[]
 >                                                                                              : ^^^^^
 >arr // should error    .filter((obj) => obj && obj.data)    .map : <U>(callbackfn: (value: MyObj, index: number, array: MyObj[]) => U, thisArg?: any) => U[]
->                                                                 : ^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                                                                 : ^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >arr // should error    .filter((obj) => obj && obj.data) : MyObj[]
 >                                                         : ^^^^^^^
 >arr // should error    .filter : { <S extends MyObj>(predicate: (value: MyObj, index: number, array: MyObj[]) => value is S, thisArg?: any): S[]; (predicate: (value: MyObj, index: number, array: MyObj[]) => unknown, thisArg?: any): MyObj[]; }
->                               : ^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^  ^^^
+>                               : ^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^
 >arr : MyObj[] | undefined
 >    : ^^^^^^^^^^^^^^^^^^^
 
     .filter((obj) => obj && obj.data)
 >filter : { <S extends MyObj>(predicate: (value: MyObj, index: number, array: MyObj[]) => value is S, thisArg?: any): S[]; (predicate: (value: MyObj, index: number, array: MyObj[]) => unknown, thisArg?: any): MyObj[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^
 >(obj) => obj && obj.data : (obj: MyObj) => string | undefined
 >                         : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >obj : MyObj
@@ -439,7 +439,7 @@ const result = myArray
 
     .map(obj => JSON.parse(obj.data))  // should error
 >map : <U>(callbackfn: (value: MyObj, index: number, array: MyObj[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >obj => JSON.parse(obj.data) : (obj: MyObj) => any
 >                            : ^   ^^^^^^^^^^^^^^^
 >obj : MyObj
@@ -467,25 +467,25 @@ const result2 = myArray
 >myArray  .map((arr) => arr.list)  .filter((arr) => !!arr)  .filter(arr => arr.length)  .map((arr) => arr  // should ok    .filter((obj) => obj)    // inferring a guard here would require https://github.com/microsoft/TypeScript/issues/42384    .filter(obj => !!obj.data)    .map(obj => JSON.parse(obj.data))  ) : any[][]
 >                                                                                                                                                                                                                                                                                                                      : ^^^^^^^
 >myArray  .map((arr) => arr.list)  .filter((arr) => !!arr)  .filter(arr => arr.length)  .map : <U>(callbackfn: (value: MyObj[], index: number, array: MyObj[][]) => U, thisArg?: any) => U[]
->                                                                                            : ^ ^^          ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                                                                                            : ^ ^^          ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >myArray  .map((arr) => arr.list)  .filter((arr) => !!arr)  .filter(arr => arr.length) : MyObj[][]
 >                                                                                      : ^^^^^^^^^
 >myArray  .map((arr) => arr.list)  .filter((arr) => !!arr)  .filter : { <S extends MyObj[]>(predicate: (value: MyObj[], index: number, array: MyObj[][]) => value is S, thisArg?: any): S[]; (predicate: (value: MyObj[], index: number, array: MyObj[][]) => unknown, thisArg?: any): MyObj[][]; }
->                                                                   : ^^^ ^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^  ^^^
+>                                                                   : ^^^ ^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^
 >myArray  .map((arr) => arr.list)  .filter((arr) => !!arr) : MyObj[][]
 >                                                          : ^^^^^^^^^
 >myArray  .map((arr) => arr.list)  .filter : { <S extends MyObj[] | undefined>(predicate: (value: MyObj[] | undefined, index: number, array: (MyObj[] | undefined)[]) => value is S, thisArg?: any): S[]; (predicate: (value: MyObj[] | undefined, index: number, array: (MyObj[] | undefined)[]) => unknown, thisArg?: any): (MyObj[] | undefined)[]; }
->                                          : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>                                          : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >myArray  .map((arr) => arr.list) : (MyObj[] | undefined)[]
 >                                 : ^^^^^^^^^^^^^^^^^^^^^^^
 >myArray  .map : <U>(callbackfn: (value: { list?: MyObj[]; }, index: number, array: { list?: MyObj[]; }[]) => U, thisArg?: any) => U[]
->              : ^ ^^          ^^^     ^^^^^^^^^^^       ^^^^^     ^^      ^^     ^^^^^^^^^^^       ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>              : ^ ^^          ^^^     ^^^^^^^^^^^       ^^^^^     ^^      ^^     ^^^^^^^^^^^       ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >myArray : MyArray
 >        : ^^^^^^^
 
   .map((arr) => arr.list)
 >map : <U>(callbackfn: (value: { list?: MyObj[]; }, index: number, array: { list?: MyObj[]; }[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^       ^^^^^     ^^      ^^     ^^^^^^^^^^^       ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^       ^^^^^     ^^      ^^     ^^^^^^^^^^^       ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(arr) => arr.list : (arr: { list?: MyObj[]; }) => MyObj[] | undefined
 >                  : ^   ^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >arr : { list?: MyObj[]; }
@@ -499,7 +499,7 @@ const result2 = myArray
 
   .filter((arr) => !!arr)
 >filter : { <S extends MyObj[] | undefined>(predicate: (value: MyObj[] | undefined, index: number, array: (MyObj[] | undefined)[]) => value is S, thisArg?: any): S[]; (predicate: (value: MyObj[] | undefined, index: number, array: (MyObj[] | undefined)[]) => unknown, thisArg?: any): (MyObj[] | undefined)[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(arr) => !!arr : (arr: MyObj[] | undefined) => arr is MyObj[]
 >               : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >arr : MyObj[] | undefined
@@ -513,7 +513,7 @@ const result2 = myArray
 
   .filter(arr => arr.length)
 >filter : { <S extends MyObj[]>(predicate: (value: MyObj[], index: number, array: MyObj[][]) => value is S, thisArg?: any): S[]; (predicate: (value: MyObj[], index: number, array: MyObj[][]) => unknown, thisArg?: any): MyObj[][]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^
 >arr => arr.length : (arr: MyObj[]) => number
 >                  : ^   ^^^^^^^^^^^^^^^^^^^^
 >arr : MyObj[]
@@ -527,7 +527,7 @@ const result2 = myArray
 
   .map((arr) => arr  // should ok
 >map : <U>(callbackfn: (value: MyObj[], index: number, array: MyObj[][]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(arr) => arr  // should ok    .filter((obj) => obj)    // inferring a guard here would require https://github.com/microsoft/TypeScript/issues/42384    .filter(obj => !!obj.data)    .map(obj => JSON.parse(obj.data)) : (arr: MyObj[]) => any[]
 >                                                                                                                                                                                                                       : ^   ^^^^^^^^^^^^^^^^^^^
 >arr : MyObj[]
@@ -535,21 +535,21 @@ const result2 = myArray
 >arr  // should ok    .filter((obj) => obj)    // inferring a guard here would require https://github.com/microsoft/TypeScript/issues/42384    .filter(obj => !!obj.data)    .map(obj => JSON.parse(obj.data)) : any[]
 >                                                                                                                                                                                                              : ^^^^^
 >arr  // should ok    .filter((obj) => obj)    // inferring a guard here would require https://github.com/microsoft/TypeScript/issues/42384    .filter(obj => !!obj.data)    .map : <U>(callbackfn: (value: MyObj, index: number, array: MyObj[]) => U, thisArg?: any) => U[]
->                                                                                                                                                                                 : ^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                                                                                                                                                                                 : ^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >arr  // should ok    .filter((obj) => obj)    // inferring a guard here would require https://github.com/microsoft/TypeScript/issues/42384    .filter(obj => !!obj.data) : MyObj[]
 >                                                                                                                                                                         : ^^^^^^^
 >arr  // should ok    .filter((obj) => obj)    // inferring a guard here would require https://github.com/microsoft/TypeScript/issues/42384    .filter : { <S extends MyObj>(predicate: (value: MyObj, index: number, array: MyObj[]) => value is S, thisArg?: any): S[]; (predicate: (value: MyObj, index: number, array: MyObj[]) => unknown, thisArg?: any): MyObj[]; }
->                                                                                                                                                      : ^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^  ^^^
+>                                                                                                                                                      : ^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^
 >arr  // should ok    .filter((obj) => obj) : MyObj[]
 >                                           : ^^^^^^^
 >arr  // should ok    .filter : { <S extends MyObj>(predicate: (value: MyObj, index: number, array: MyObj[]) => value is S, thisArg?: any): S[]; (predicate: (value: MyObj, index: number, array: MyObj[]) => unknown, thisArg?: any): MyObj[]; }
->                             : ^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^  ^^^
+>                             : ^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^
 >arr : MyObj[]
 >    : ^^^^^^^
 
     .filter((obj) => obj)
 >filter : { <S extends MyObj>(predicate: (value: MyObj, index: number, array: MyObj[]) => value is S, thisArg?: any): S[]; (predicate: (value: MyObj, index: number, array: MyObj[]) => unknown, thisArg?: any): MyObj[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^
 >(obj) => obj : (obj: MyObj) => MyObj
 >             : ^   ^^^^^^^^^^^^^^^^^
 >obj : MyObj
@@ -560,7 +560,7 @@ const result2 = myArray
     // inferring a guard here would require https://github.com/microsoft/TypeScript/issues/42384
     .filter(obj => !!obj.data)
 >filter : { <S extends MyObj>(predicate: (value: MyObj, index: number, array: MyObj[]) => value is S, thisArg?: any): S[]; (predicate: (value: MyObj, index: number, array: MyObj[]) => unknown, thisArg?: any): MyObj[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^
 >obj => !!obj.data : (obj: MyObj) => boolean
 >                  : ^   ^^^^^^^^^^^^^^^^^^^
 >obj : MyObj
@@ -578,7 +578,7 @@ const result2 = myArray
 
     .map(obj => JSON.parse(obj.data))
 >map : <U>(callbackfn: (value: MyObj, index: number, array: MyObj[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >obj => JSON.parse(obj.data) : (obj: MyObj) => any
 >                            : ^   ^^^^^^^^^^^^^^^
 >obj : MyObj
@@ -630,11 +630,11 @@ const resultBars: Bar[] = list.filter((value) => 'bar' in value);  // should ok
 >list.filter((value) => 'bar' in value) : Bar[]
 >                                       : ^^^^^
 >list.filter : { <S extends Foo | Bar>(predicate: (value: Foo | Bar, index: number, array: (Foo | Bar)[]) => value is S, thisArg?: any): S[]; (predicate: (value: Foo | Bar, index: number, array: (Foo | Bar)[]) => unknown, thisArg?: any): (Foo | Bar)[]; }
->            : ^^^ ^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^  ^^^
+>            : ^^^ ^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^
 >list : (Foo | Bar)[]
 >     : ^^^^^^^^^^^^^
 >filter : { <S extends Foo | Bar>(predicate: (value: Foo | Bar, index: number, array: (Foo | Bar)[]) => value is S, thisArg?: any): S[]; (predicate: (value: Foo | Bar, index: number, array: (Foo | Bar)[]) => unknown, thisArg?: any): (Foo | Bar)[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^
 >(value) => 'bar' in value : (value: Foo | Bar) => value is Bar
 >                          : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value : Foo | Bar
@@ -697,7 +697,7 @@ const a = [1, "foo", 2, "bar"].filter(x => typeof x === "string");
 >[1, "foo", 2, "bar"].filter(x => typeof x === "string") : string[]
 >                                                        : ^^^^^^^^
 >[1, "foo", 2, "bar"].filter : { <S extends string | number>(predicate: (value: string | number, index: number, array: (string | number)[]) => value is S, thisArg?: any): S[]; (predicate: (value: string | number, index: number, array: (string | number)[]) => unknown, thisArg?: any): (string | number)[]; }
->                            : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^  ^^^
+>                            : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^
 >[1, "foo", 2, "bar"] : (string | number)[]
 >                     : ^^^^^^^^^^^^^^^^^^^
 >1 : 1
@@ -709,7 +709,7 @@ const a = [1, "foo", 2, "bar"].filter(x => typeof x === "string");
 >"bar" : "bar"
 >      : ^^^^^
 >filter : { <S extends string | number>(predicate: (value: string | number, index: number, array: (string | number)[]) => value is S, thisArg?: any): S[]; (predicate: (value: string | number, index: number, array: (string | number)[]) => unknown, thisArg?: any): (string | number)[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => typeof x === "string" : (x: string | number) => x is string
 >                           : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : string | number
diff --git a/tests/baselines/reference/inferTypes1.types b/tests/baselines/reference/inferTypes1.types
index 5001a60e99842..edc97a2ea14c0 100644
--- a/tests/baselines/reference/inferTypes1.types
+++ b/tests/baselines/reference/inferTypes1.types
@@ -690,7 +690,7 @@ const result = invoker('test', true)({ test: (a: boolean) => 123 })
 >invoker('test', true)({ test: (a: boolean) => 123 }) : number
 >                                                     : ^^^^^^
 >invoker('test', true) : <T extends Record<"test", (args_0: boolean) => any>>(obj: T) => ReturnType<T["test"]>
->                      : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^   ^^^^^^^^           ^^^^^^^^^ 
+>                      : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >invoker : <K extends string | number | symbol, A extends any[]>(key: K, ...args: A) => <T extends Record<K, (...args: A) => any>>(obj: T) => ReturnType<T[K]>
 >        : ^ ^^^^^^^^^                        ^^ ^^^^^^^^^     ^^   ^^ ^^^^^    ^^ ^^^^^^ ^^^^^^^^^                              ^^   ^^ ^^^^^                
 >'test' : "test"
diff --git a/tests/baselines/reference/inferenceAndHKTs.types b/tests/baselines/reference/inferenceAndHKTs.types
index 73865eeb0ec4e..62c063d89bd6c 100644
--- a/tests/baselines/reference/inferenceAndHKTs.types
+++ b/tests/baselines/reference/inferenceAndHKTs.types
@@ -64,10 +64,10 @@ declare const a: T<number>;
 >  : ^^^^^^^^^
 
 const x1 = map(typeClass);
->x1 : <A, B>(a: T<A>, f: (a: A) => B) => Apply<TTypeLambda, B>
->   : ^ ^^ ^^ ^^^^^^^^ ^^^ ^^^^^^^^^^^^^^      ^^^^^^^^^^^  ^ 
->map(typeClass) : <A, B>(a: T<A>, f: (a: A) => B) => Apply<TTypeLambda, B>
->               : ^ ^^ ^^ ^^^^^^^^ ^^^ ^^^^^^^^^^^^^^      ^^^^^^^^^^^  ^ 
+>x1 : <A, B>(a: T<A>, f: (a: A) => B) => T<B>
+>   : ^ ^^ ^^ ^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^
+>map(typeClass) : <A, B>(a: T<A>, f: (a: A) => B) => T<B>
+>               : ^ ^^ ^^ ^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^
 >map : <F extends TypeLambda>(F: TypeClass<F>) => <A, B>(a: Apply<F, A>, f: (a: A) => B) => Apply<F, B>
 >    : ^ ^^^^^^^^^          ^^ ^^            ^^^^^                                                     
 >typeClass : TypeClass<TTypeLambda>
@@ -78,8 +78,8 @@ const x2 = map(typeClass)(a, (_) => _);  // T<number>
 >   : ^^^^^^^^^
 >map(typeClass)(a, (_) => _) : T<number>
 >                            : ^^^^^^^^^
->map(typeClass) : <A, B>(a: T<A>, f: (a: A) => B) => Apply<TTypeLambda, B>
->               : ^ ^^ ^^ ^^^^^^^^ ^^^ ^^^^^^^^^^^^^^      ^^^^^^^^^^^  ^ 
+>map(typeClass) : <A, B>(a: T<A>, f: (a: A) => B) => T<B>
+>               : ^ ^^ ^^ ^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^
 >map : <F extends TypeLambda>(F: TypeClass<F>) => <A, B>(a: Apply<F, A>, f: (a: A) => B) => Apply<F, B>
 >    : ^ ^^^^^^^^^          ^^ ^^            ^^^^^                                                     
 >typeClass : TypeClass<TTypeLambda>
diff --git a/tests/baselines/reference/inferenceLimit.types b/tests/baselines/reference/inferenceLimit.types
index fb715e40ca8b9..bb31cbbd3a13a 100644
--- a/tests/baselines/reference/inferenceLimit.types
+++ b/tests/baselines/reference/inferenceLimit.types
@@ -68,7 +68,7 @@ export class BrokenClass {
 >this.doStuff(order.id)          .then((items) => {            order.items = items;            resolve(order);          }) : Promise<void>
 >                                                                                                                          : ^^^^^^^^^^^^^
 >this.doStuff(order.id)          .then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                                      : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                                      : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.doStuff(order.id) : Promise<void>
 >                       : ^^^^^^^^^^^^^
 >this.doStuff : (id: number) => Promise<void>
@@ -85,7 +85,7 @@ export class BrokenClass {
 
           .then((items) => {
 >then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(items) => {            order.items = items;            resolve(order);          } : (items: void) => void
 >                                                                                   : ^     ^^^^^^^^^^^^^^^
 >items : void
@@ -117,7 +117,7 @@ export class BrokenClass {
 >Promise.all(result.map(populateItems))      .then((orders: Array<MyModule.MyModel>) => {        resolve(orders);      }) : Promise<void>
 >                                                                                                                         : ^^^^^^^^^^^^^
 >Promise.all(result.map(populateItems))      .then : <TResult1 = unknown[], TResult2 = never>(onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                                                  : ^        ^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                                                  : ^        ^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Promise.all(result.map(populateItems)) : Promise<unknown[]>
 >                                       : ^^^^^^^^^^^^^^^^^^
 >Promise.all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>; <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>; }
@@ -129,17 +129,17 @@ export class BrokenClass {
 >result.map(populateItems) : Promise<unknown>[]
 >                          : ^^^^^^^^^^^^^^^^^^
 >result.map : <U>(callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[]
->           : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>           : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >result : MyModule.MyModel[]
 >       : ^^^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: MyModule.MyModel, index: number, array: MyModule.MyModel[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >populateItems : (order: any) => Promise<unknown>
 >              : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
       .then((orders: Array<MyModule.MyModel>) => {
 >then : <TResult1 = unknown[], TResult2 = never>(onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(orders: Array<MyModule.MyModel>) => {        resolve(orders);      } : (orders: Array<MyModule.MyModel>) => void
 >                                                                      : ^      ^^                       ^^^^^^^^^
 >orders : MyModule.MyModel[]
diff --git a/tests/baselines/reference/inferenceOptionalPropertiesToIndexSignatures.types b/tests/baselines/reference/inferenceOptionalPropertiesToIndexSignatures.types
index a81a94d2b4e5f..dbdf6925d6819 100644
--- a/tests/baselines/reference/inferenceOptionalPropertiesToIndexSignatures.types
+++ b/tests/baselines/reference/inferenceOptionalPropertiesToIndexSignatures.types
@@ -141,7 +141,7 @@ const query = Object.entries(obj).map(
 >Object.entries(obj).map(    ([k, v]) => `${k}=${encodeURIComponent(v)}`) : string[]
 >                                                                         : ^^^^^^^^
 >Object.entries(obj).map : <U>(callbackfn: (value: [string, string], index: number, array: [string, string][]) => U, thisArg?: any) => U[]
->                        : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                        : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >Object.entries(obj) : [string, string][]
 >                    : ^^^^^^^^^^^^^^^^^^
 >Object.entries : { <T>(o: { [s: string]: T; } | ArrayLike<T>): [string, T][]; (o: {}): [string, any][]; }
@@ -153,7 +153,7 @@ const query = Object.entries(obj).map(
 >obj : { param2?: string | undefined; param1: string; }
 >    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: [string, string], index: number, array: [string, string][]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 
     ([k, v]) => `${k}=${encodeURIComponent(v)}`
 >([k, v]) => `${k}=${encodeURIComponent(v)}` : ([k, v]: [string, string]) => string
diff --git a/tests/baselines/reference/inferentialTypingWithFunctionType2.types b/tests/baselines/reference/inferentialTypingWithFunctionType2.types
index 33f2dac53f172..f55d9e712fc0b 100644
--- a/tests/baselines/reference/inferentialTypingWithFunctionType2.types
+++ b/tests/baselines/reference/inferentialTypingWithFunctionType2.types
@@ -19,7 +19,7 @@ var x = [1, 2, 3].map(identity)[0];
 >[1, 2, 3].map(identity) : number[]
 >                        : ^^^^^^^^
 >[1, 2, 3].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->              : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>              : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1, 2, 3] : number[]
 >          : ^^^^^^^^
 >1 : 1
@@ -29,7 +29,7 @@ var x = [1, 2, 3].map(identity)[0];
 >3 : 3
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >identity : <A>(a: A) => A
 >         : ^ ^^ ^^ ^^^^^ 
 >0 : 0
diff --git a/tests/baselines/reference/instantiateContextualTypes.types b/tests/baselines/reference/instantiateContextualTypes.types
index bfcb01f7307bf..e51df99d1d857 100644
--- a/tests/baselines/reference/instantiateContextualTypes.types
+++ b/tests/baselines/reference/instantiateContextualTypes.types
@@ -494,7 +494,7 @@ class Interesting {
 >Promise.resolve().then(() => {			if (1 < 2) {				return 'SOMETHING';			}			return 'ELSE';		}) : Promise<"SOMETHING" | "ELSE">
 >                                                                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->                       : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                       : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve() : Promise<void>
 >                  : ^^^^^^^^^^^^^
 >Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
@@ -504,7 +504,7 @@ class Interesting {
 >resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >        : ^^^^^^             ^^^ ^^     ^^ ^^^                   ^^^ ^^     ^^                  ^^^                   ^^^
 >then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {			if (1 < 2) {				return 'SOMETHING';			}			return 'ELSE';		} : () => "SOMETHING" | "ELSE"
 >                                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -536,7 +536,7 @@ class Interesting {
 >Promise.resolve().then(() => {			return 'ELSE';		}) : Promise<"SOMETHING" | "ELSE">
 >                                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->                       : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                       : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve() : Promise<void>
 >                  : ^^^^^^^^^^^^^
 >Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
@@ -546,7 +546,7 @@ class Interesting {
 >resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >        : ^^^^^^             ^^^ ^^     ^^ ^^^                   ^^^ ^^     ^^                  ^^^                   ^^^
 >then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {			return 'ELSE';		} : () => "ELSE"
 >                            : ^^^^^^^^^^^^
 
@@ -566,7 +566,7 @@ class Interesting {
 >Promise.resolve().then(() => {			if (1 < 2) {				return 'SOMETHING';			}			return 'SOMETHING';		}) : Promise<"SOMETHING" | "ELSE">
 >                                                                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->                       : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                       : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve() : Promise<void>
 >                  : ^^^^^^^^^^^^^
 >Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
@@ -576,7 +576,7 @@ class Interesting {
 >resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >        : ^^^^^^             ^^^ ^^     ^^ ^^^                   ^^^ ^^     ^^                  ^^^                   ^^^
 >then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {			if (1 < 2) {				return 'SOMETHING';			}			return 'SOMETHING';		} : () => "SOMETHING"
 >                                                                           : ^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/instantiationExpressions.types b/tests/baselines/reference/instantiationExpressions.types
index aa64f25daa768..4b3156a650df7 100644
--- a/tests/baselines/reference/instantiationExpressions.types
+++ b/tests/baselines/reference/instantiationExpressions.types
@@ -43,9 +43,9 @@ function f1() {
 
     let f2 = fx<string, number>;  // (t: [string, number]) => [string, number]
 >f2 : (t: [string, number]) => [string, number]
->   : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^  ^^^^^^ 
+>   : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >fx<string, number> : (t: [string, number]) => [string, number]
->                   : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^  ^^^^^^ 
+>                   : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >fx : { <T>(x: T): T; <T>(x: T, n: number): T; <T, U>(t: [T, U]): [T, U]; }
 >   : ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^      ^^^ ^^^ ^^ ^^ ^^      ^^^      ^^^
 
@@ -96,9 +96,9 @@ function f2() {
 
     const A1 = Array<string>;  // new (...) => string[]
 >A1 : { (arrayLength: number): string[]; (...items: string[]): string[]; new (arrayLength: number): string[]; new (...items: string[]): string[]; isArray(arg: any): arg is any[]; readonly prototype: any[]; }
->   : ^^^           ^^      ^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^^^^^           ^^      ^^^^^^^^^  ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^   ^^   ^^^            ^^^^^^^^^^^^^^^^^^^^^^     ^^^
+>   : ^^^           ^^      ^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^           ^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^   ^^^            ^^^^^^^^^^^^^^^^^^^^^^     ^^^
 >Array<string> : { (arrayLength: number): string[]; (...items: string[]): string[]; new (arrayLength: number): string[]; new (...items: string[]): string[]; isArray(arg: any): arg is any[]; readonly prototype: any[]; }
->              : ^^^           ^^      ^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^^^^^           ^^      ^^^^^^^^^  ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^   ^^   ^^^            ^^^^^^^^^^^^^^^^^^^^^^     ^^^
+>              : ^^^           ^^      ^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^           ^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^   ^^^            ^^^^^^^^^^^^^^^^^^^^^^     ^^^
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
 
@@ -158,9 +158,9 @@ function f3() {
 
     let f1 = C.f<string>;  // (x: string) => string[]
 >f1 : (x: string) => string[]
->   : ^ ^^^^^^^^^^^^^^^^^^^  
+>   : ^ ^^^^^^^^^^^^^^^^^^^^^
 >C.f<string> : (x: string) => string[]
->            : ^ ^^^^^^^^^^^^^^^^^^^  
+>            : ^ ^^^^^^^^^^^^^^^^^^^^^
 >C.f : <U>(x: U) => U[]
 >    : ^ ^^ ^^ ^^^^^   
 >C : typeof C
@@ -183,9 +183,9 @@ function f10(f: { <T>(a: T): T, <U>(a: U, b: number): U[] }) {
 
     let fs = f<string>;  // { (a: string): string; (a: string, b: number): string[]; }
 >fs : { (a: string): string; (a: string, b: number): string[]; }
->   : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^  ^^^
+>   : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f<string> : { (a: string): string; (a: string, b: number): string[]; }
->          : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^  ^^^
+>          : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f : { <T>(a: T): T; <U>(a: U, b: number): U[]; }
 >  : ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^      ^^^   ^^^
 }
@@ -263,9 +263,9 @@ function f14(f: { new <T>(a: T): T, new <U>(a: U, b: number): U[] }) {
 
     let fs = f<string>;  // { new (a: string): string; new (a: string, b: number): string[]; }
 >fs : { new (a: string): string; new (a: string, b: number): string[]; }
->   : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^  ^^^
+>   : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f<string> : { new (a: string): string; new (a: string, b: number): string[]; }
->          : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^  ^^^
+>          : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f : { new <T>(a: T): T; new <U>(a: U, b: number): U[]; }
 >  : ^^^^^^^ ^^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^ ^^      ^^^   ^^^
 }
@@ -284,9 +284,9 @@ function f15(f: { new <T>(a: T): T, <U>(a: U, b: number): U[] }) {
 
     let fs = f<string>;  // { new (a: string): string; (a: string, b: number): string[]; }
 >fs : { (a: string, b: number): string[]; new (a: string): string; }
->   : ^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^  ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
+>   : ^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
 >f<string> : { (a: string, b: number): string[]; new (a: string): string; }
->          : ^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^  ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
+>          : ^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
 >f : { <U>(a: U, b: number): U[]; new <T>(a: T): T; }
 >  : ^^^ ^^ ^^ ^^ ^^      ^^^   ^^^^^^^ ^^ ^^ ^^^ ^^^
 }
@@ -347,9 +347,9 @@ function f20(f: (<T>(a: T) => T) & (<U>(a: U, b: number) => U[])) {
 
     let fs = f<string>;  // ((a: string) => string) & ((a: string, b: number) => string[]])
 >fs : ((a: string) => string) & ((a: string, b: number) => string[])
->   : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^  ^
+>   : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f<string> : ((a: string) => string) & ((a: string, b: number) => string[])
->          : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^  ^
+>          : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f : (<T>(a: T) => T) & (<U>(a: U, b: number) => U[])
 >  : ^^ ^^ ^^ ^^^^^ ^^^^^^ ^^ ^^ ^^ ^^      ^^^^^   ^
 }
@@ -427,9 +427,9 @@ function f24(f: (new <T>(a: T) => T) & (new <U>(a: U, b: number) => U[])) {
 
     let fs = f<string>;  // (new (a: string) => string) & ((a: string, b: number) => string[]])
 >fs : (new (a: string) => string) & (new (a: string, b: number) => string[])
->   : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^  ^
+>   : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f<string> : (new (a: string) => string) & (new (a: string, b: number) => string[])
->          : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^  ^
+>          : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f : (new <T>(a: T) => T) & (new <U>(a: U, b: number) => U[])
 >  : ^^^^^^ ^^ ^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^      ^^^^^   ^
 }
@@ -448,9 +448,9 @@ function f25(f: (new <T>(a: T) => T) & (<U>(a: U, b: number) => U[])) {
 
     let fs = f<string>;  // (new (a: string) => string) & ((a: string, b: number) => string[]])
 >fs : (new (a: string) => string) & ((a: string, b: number) => string[])
->   : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^  ^
+>   : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f<string> : (new (a: string) => string) & ((a: string, b: number) => string[])
->          : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^  ^
+>          : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f : (new <T>(a: T) => T) & (<U>(a: U, b: number) => U[])
 >  : ^^^^^^ ^^ ^^ ^^^^^ ^^^^^^ ^^ ^^ ^^ ^^      ^^^^^   ^
 }
@@ -511,9 +511,9 @@ function f30(f: (<T>(a: T) => T) | (<U>(a: U, b: number) => U[])) {
 
     let fs = f<string>;  // ((a: string) => string) | ((a: string, b: number) => string[]])
 >fs : ((a: string) => string) | ((a: string, b: number) => string[])
->   : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^  ^
+>   : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f<string> : ((a: string) => string) | ((a: string, b: number) => string[])
->          : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^  ^
+>          : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f : (<T>(a: T) => T) | (<U>(a: U, b: number) => U[])
 >  : ^^ ^^ ^^ ^^^^^ ^^^^^^ ^^ ^^ ^^ ^^      ^^^^^   ^
 }
@@ -591,9 +591,9 @@ function f34(f: (new <T>(a: T) => T) | (new <U>(a: U, b: number) => U[])) {
 
     let fs = f<string>;  // (new (a: string) => string) | ((a: string, b: number) => string[]])
 >fs : (new (a: string) => string) | (new (a: string, b: number) => string[])
->   : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^  ^
+>   : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f<string> : (new (a: string) => string) | (new (a: string, b: number) => string[])
->          : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^  ^
+>          : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f : (new <T>(a: T) => T) | (new <U>(a: U, b: number) => U[])
 >  : ^^^^^^ ^^ ^^ ^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^      ^^^^^   ^
 }
@@ -612,9 +612,9 @@ function f35(f: (new <T>(a: T) => T) | (<U>(a: U, b: number) => U[])) {
 
     let fs = f<string>;  // (new (a: string) => string) | ((a: string, b: number) => string[]])
 >fs : (new (a: string) => string) | ((a: string, b: number) => string[])
->   : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^  ^
+>   : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f<string> : (new (a: string) => string) | ((a: string, b: number) => string[])
->          : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^  ^
+>          : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^      ^^^^^^^^^^^^^^
 >f : (new <T>(a: T) => T) | (<U>(a: U, b: number) => U[])
 >  : ^^^^^^ ^^ ^^ ^^^^^ ^^^^^^ ^^ ^^ ^^ ^^      ^^^^^   ^
 }
@@ -675,9 +675,9 @@ function f38<T extends (<A>(x: A) => A) | (<B>(x: B) => B[]), U>(f: T | U | (<C>
 
     let fs = f<string>;  // U | ((x: string) => string) | ((x: string) => string[]) | ((x: string) => string[][])
 >fs : U | ((x: string) => string) | ((x: string) => string[]) | ((x: string) => string[][])
->   : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^  ^^^^^^ ^^^^^^^^^^^^^^^^^^^    ^
+>   : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >f<string> : U | ((x: string) => string) | ((x: string) => string[]) | ((x: string) => string[][])
->          : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^  ^^^^^^ ^^^^^^^^^^^^^^^^^^^    ^
+>          : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >f : T | U | (<C>(x: C) => C[][])
 >  : ^^^^^^^^^^ ^^ ^^ ^^^^^     ^
 }
diff --git a/tests/baselines/reference/intersectionThisTypes.types b/tests/baselines/reference/intersectionThisTypes.types
index e50bcd44801b2..b3cca39f4f8d0 100644
--- a/tests/baselines/reference/intersectionThisTypes.types
+++ b/tests/baselines/reference/intersectionThisTypes.types
@@ -154,24 +154,24 @@ function test(label: Label) {
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >label.extend({ id: 67 }).extend({ tag: "hello" }) : Label & { id: number; } & { tag: string; }
 >                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->label.extend({ id: 67 }).extend : <T>(props: T) => (Label & { id: number; }) & T
->                                : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^
+>label.extend({ id: 67 }).extend : <T>(props: T) => Label & { id: number; } & T
+>                                : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >label.extend({ id: 67 }) : Label & { id: number; }
 >                         : ^^^^^^^^^^^^^^^^^^^^^^^
 >label.extend : <T>(props: T) => Label & T
->             : ^ ^^     ^^^^^^^^^^^^^   ^
+>             : ^ ^^     ^^^^^^^^^^^^^^^^^
 >label : Label
 >      : ^^^^^
 >extend : <T>(props: T) => Label & T
->       : ^ ^^     ^^^^^^^^^^^^^   ^
+>       : ^ ^^     ^^^^^^^^^^^^^^^^^
 >{ id: 67 } : { id: number; }
 >           : ^^^^^^^^^^^^^^^
 >id : number
 >   : ^^^^^^
 >67 : 67
 >   : ^^
->extend : <T>(props: T) => (Label & { id: number; }) & T
->       : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^
+>extend : <T>(props: T) => Label & { id: number; } & T
+>       : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >{ tag: "hello" } : { tag: string; }
 >                 : ^^^^^^^^^^^^^^^^
 >tag : string
diff --git a/tests/baselines/reference/intersectionTypeInference3.types b/tests/baselines/reference/intersectionTypeInference3.types
index 7d1a6c2a650d4..bfa287452f9df 100644
--- a/tests/baselines/reference/intersectionTypeInference3.types
+++ b/tests/baselines/reference/intersectionTypeInference3.types
@@ -37,7 +37,7 @@ const c1 = Array.from(a).concat(Array.from(b));
 >Array.from(a).concat(Array.from(b)) : A[]
 >                                    : ^^^
 >Array.from(a).concat : { (...items: ConcatArray<A>[]): A[]; (...items: (A | ConcatArray<A>)[]): A[]; }
->                     : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>                     : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Array.from(a) : A[]
 >              : ^^^
 >Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T> | ArrayLike<T>): T[]; <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
@@ -49,7 +49,7 @@ const c1 = Array.from(a).concat(Array.from(b));
 >a : Set<A>
 >  : ^^^^^^
 >concat : { (...items: ConcatArray<A>[]): A[]; (...items: (A | ConcatArray<A>)[]): A[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Array.from(b) : A[]
 >              : ^^^
 >Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T> | ArrayLike<T>): T[]; <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
diff --git a/tests/baselines/reference/invalidSplice.types b/tests/baselines/reference/invalidSplice.types
index ff4aae7acd41b..7d436e88051fe 100644
--- a/tests/baselines/reference/invalidSplice.types
+++ b/tests/baselines/reference/invalidSplice.types
@@ -7,11 +7,11 @@ var arr = [].splice(0,3,4,5);
 >[].splice(0,3,4,5) : any[]
 >                   : ^^^^^
 >[].splice : { (start: number, deleteCount?: number): any[]; (start: number, deleteCount: number, ...items: any[]): any[]; }
->          : ^^^     ^^      ^^           ^^^      ^^^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^  ^^^
+>          : ^^^     ^^      ^^           ^^^      ^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 >splice : { (start: number, deleteCount?: number): any[]; (start: number, deleteCount: number, ...items: any[]): any[]; }
->       : ^^^     ^^      ^^           ^^^      ^^^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^  ^^^
+>       : ^^^     ^^      ^^           ^^^      ^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 >3 : 3
diff --git a/tests/baselines/reference/ipromise2.types b/tests/baselines/reference/ipromise2.types
index f73d0b3c0473b..c1aa41840d674 100644
--- a/tests/baselines/reference/ipromise2.types
+++ b/tests/baselines/reference/ipromise2.types
@@ -109,11 +109,11 @@ var p2 = p.then(function (s) {
 >p.then(function (s) {    return 34;} ) : Windows.Foundation.IPromise<number>
 >                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : { <U>(success?: (value: string) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: string) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; }
->       : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^
+>       : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Windows.Foundation.IPromise<string>
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: string) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >function (s) {    return 34;} : (s: string) => number
 >                              : ^ ^^^^^^^^^^^^^^^^^^^
 >s : string
diff --git a/tests/baselines/reference/ipromise3.types b/tests/baselines/reference/ipromise3.types
index 4dc192225e52c..b8bc12ac7226c 100644
--- a/tests/baselines/reference/ipromise3.types
+++ b/tests/baselines/reference/ipromise3.types
@@ -82,11 +82,11 @@ var p2: IPromise3<string> = p1.then(function (x) {
 >p1.then(function (x) {    return x;}) : IPromise3<string>
 >                                      : ^^^^^^^^^^^^^^^^^
 >p1.then : { <U>(success?: (value: string) => IPromise3<U>, error?: (error: any) => IPromise3<U>, progress?: (progress: any) => void): IPromise3<U>; <U>(success?: (value: string) => IPromise3<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise3<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise3<U>, progress?: (progress: any) => void): IPromise3<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise3<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^          ^ ^^     ^^^^     ^^   ^^^^^          ^ ^^        ^^^                       ^^^          ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^          ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^          ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^          ^ ^^        ^^^                       ^^^          ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^          ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^
 >p1 : IPromise3<string>
 >   : ^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise3<U>, error?: (error: any) => IPromise3<U>, progress?: (progress: any) => void): IPromise3<U>; <U>(success?: (value: string) => IPromise3<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise3<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise3<U>, progress?: (progress: any) => void): IPromise3<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise3<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^          ^ ^^     ^^^^     ^^   ^^^^^          ^ ^^        ^^^                       ^^^          ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^          ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^          ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^          ^ ^^        ^^^                       ^^^          ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^          ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^
 >function (x) {    return x;} : (x: string) => string
 >                             : ^ ^^^^^^^^^^^^^^^^^^^
 >x : string
diff --git a/tests/baselines/reference/ipromise4.types b/tests/baselines/reference/ipromise4.types
index ab084cdc26cbe..46e5e4a020eea 100644
--- a/tests/baselines/reference/ipromise4.types
+++ b/tests/baselines/reference/ipromise4.types
@@ -103,11 +103,11 @@ p.then(function (x) { } ); // should not error
 >p.then(function (x) { } ) : Windows.Foundation.IPromise<void>
 >                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : { <U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; }
->       : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^
+>       : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Windows.Foundation.IPromise<number>
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >function (x) { } : (x: number) => void
 >                 : ^ ^^^^^^^^^^^^^^^^^
 >x : number
@@ -117,15 +117,15 @@ p.then(function (x) { return "hello"; } ).then(function (x) { return x } ); // s
 >p.then(function (x) { return "hello"; } ).then(function (x) { return x } ) : Windows.Foundation.IPromise<string>
 >                                                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then(function (x) { return "hello"; } ).then : { <U>(success?: (value: string) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: string) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; }
->                                               : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^
+>                                               : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then(function (x) { return "hello"; } ) : Windows.Foundation.IPromise<string>
 >                                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : { <U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; }
->       : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^
+>       : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Windows.Foundation.IPromise<number>
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >function (x) { return "hello"; } : (x: number) => string
 >                                 : ^ ^^^^^^^^^^^^^^^^^^^
 >x : number
@@ -133,7 +133,7 @@ p.then(function (x) { return "hello"; } ).then(function (x) { return x } ); // s
 >"hello" : "hello"
 >        : ^^^^^^^
 >then : { <U>(success?: (value: string) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: string) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^        ^^^                       ^^^                            ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^                            ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >function (x) { return x } : (x: string) => string
 >                          : ^ ^^^^^^^^^^^^^^^^^^^
 >x : string
diff --git a/tests/baselines/reference/iteratorSpreadInArray6.types b/tests/baselines/reference/iteratorSpreadInArray6.types
index 0cfd7122bb037..6762d8bf9b941 100644
--- a/tests/baselines/reference/iteratorSpreadInArray6.types
+++ b/tests/baselines/reference/iteratorSpreadInArray6.types
@@ -60,11 +60,11 @@ array.concat([...new SymbolIterator]);
 >array.concat([...new SymbolIterator]) : number[]
 >                                      : ^^^^^^^^
 >array.concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
->             : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>             : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
 >concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[...new SymbolIterator] : symbol[]
 >                        : ^^^^^^^^
 >...new SymbolIterator : symbol
diff --git a/tests/baselines/reference/iteratorSpreadInArray7.types b/tests/baselines/reference/iteratorSpreadInArray7.types
index e20e37747488d..9f1a5e391fd7e 100644
--- a/tests/baselines/reference/iteratorSpreadInArray7.types
+++ b/tests/baselines/reference/iteratorSpreadInArray7.types
@@ -54,11 +54,11 @@ array.concat([...new SymbolIterator]);
 >array.concat([...new SymbolIterator]) : symbol[]
 >                                      : ^^^^^^^^
 >array.concat : { (...items: ConcatArray<symbol>[]): symbol[]; (...items: (symbol | ConcatArray<symbol>)[]): symbol[]; }
->             : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>             : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >array : symbol[]
 >      : ^^^^^^^^
 >concat : { (...items: ConcatArray<symbol>[]): symbol[]; (...items: (symbol | ConcatArray<symbol>)[]): symbol[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[...new SymbolIterator] : symbol[]
 >                        : ^^^^^^^^
 >...new SymbolIterator : symbol
diff --git a/tests/baselines/reference/jsxJsxsCjsTransformNestedSelfClosingChild(jsx=react-jsx).types b/tests/baselines/reference/jsxJsxsCjsTransformNestedSelfClosingChild(jsx=react-jsx).types
index 832ea31b18540..6c9f967278f60 100644
--- a/tests/baselines/reference/jsxJsxsCjsTransformNestedSelfClosingChild(jsx=react-jsx).types
+++ b/tests/baselines/reference/jsxJsxsCjsTransformNestedSelfClosingChild(jsx=react-jsx).types
@@ -94,7 +94,7 @@ console.log(
 >[1, 2].map(i => <div key={i}>{i}</div>) : JSX.Element[]
 >                                        : ^^^^^^^^^^^^^
 >[1, 2].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->           : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>           : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1, 2] : number[]
 >       : ^^^^^^^^
 >1 : 1
@@ -102,7 +102,7 @@ console.log(
 >2 : 2
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >i => <div key={i}>{i}</div> : (i: number) => JSX.Element
 >                            : ^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >i : number
diff --git a/tests/baselines/reference/jsxJsxsCjsTransformNestedSelfClosingChild(jsx=react-jsxdev).types b/tests/baselines/reference/jsxJsxsCjsTransformNestedSelfClosingChild(jsx=react-jsxdev).types
index 832ea31b18540..6c9f967278f60 100644
--- a/tests/baselines/reference/jsxJsxsCjsTransformNestedSelfClosingChild(jsx=react-jsxdev).types
+++ b/tests/baselines/reference/jsxJsxsCjsTransformNestedSelfClosingChild(jsx=react-jsxdev).types
@@ -94,7 +94,7 @@ console.log(
 >[1, 2].map(i => <div key={i}>{i}</div>) : JSX.Element[]
 >                                        : ^^^^^^^^^^^^^
 >[1, 2].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->           : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>           : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1, 2] : number[]
 >       : ^^^^^^^^
 >1 : 1
@@ -102,7 +102,7 @@ console.log(
 >2 : 2
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >i => <div key={i}>{i}</div> : (i: number) => JSX.Element
 >                            : ^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >i : number
diff --git a/tests/baselines/reference/keyofAndIndexedAccess.types b/tests/baselines/reference/keyofAndIndexedAccess.types
index bd6545897debe..b2a181563045a 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess.types
+++ b/tests/baselines/reference/keyofAndIndexedAccess.types
@@ -695,11 +695,11 @@ function pluck<T, K extends keyof T>(array: T[], key: K) {
 >array.map(x => x[key]) : T[K][]
 >                       : ^^^^^^
 >array.map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
->          : ^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>          : ^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >array : T[]
 >      : ^^^
 >map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >x => x[key] : (x: T) => T[K]
 >            : ^ ^^^^^^^^^^^^
 >x : T
@@ -2575,12 +2575,12 @@ let c1 = new Component1({
 c1.get("hello");
 >c1.get("hello") : string
 >                : ^^^^^^
->c1.get : <K extends "hello">(key: K) => ({ hello: string; } & unknown)[K]
->       : ^ ^^^^^^^^^^^^^^^^^^   ^^^^^^^^ ^^^^^^^^^^^^^^^^^^   ^^^^^^^  ^ 
+>c1.get : <K extends "hello">(key: K) => { hello: string; }[K]
+>       : ^ ^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >c1 : Component1<{ hello: string; }, unknown>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->get : <K extends "hello">(key: K) => ({ hello: string; } & unknown)[K]
->    : ^ ^^^^^^^^^^^^^^^^^^   ^^^^^^^^ ^^^^^^^^^^^^^^^^^^   ^^^^^^^  ^ 
+>get : <K extends "hello">(key: K) => { hello: string; }[K]
+>    : ^ ^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >"hello" : "hello"
 >        : ^^^^^^^
 
diff --git a/tests/baselines/reference/keyofAndIndexedAccess2.types b/tests/baselines/reference/keyofAndIndexedAccess2.types
index b6b09c85171eb..526abef4fd1bf 100644
--- a/tests/baselines/reference/keyofAndIndexedAccess2.types
+++ b/tests/baselines/reference/keyofAndIndexedAccess2.types
@@ -611,11 +611,11 @@ export function getAllEntities<E extends Entity>(state: EntityState<E>): E[] {
 >ids.map(id => entities[id]) : { [key: string]: E; [key: number]: E; }[IdOf<E>][]
 >                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >ids.map : <U>(callbackfn: (value: IdOf<E>, index: number, array: IdOf<E>[]) => U, thisArg?: any) => U[]
->        : ^ ^^          ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>        : ^ ^^          ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >ids : IdOf<E>[]
 >    : ^^^^^^^^^
 >map : <U>(callbackfn: (value: IdOf<E>, index: number, array: IdOf<E>[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >id => entities[id] : (id: IdOf<E>) => { [key: string]: E; [key: number]: E; }[IdOf<E>]
 >                   : ^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >id : IdOf<E>
diff --git a/tests/baselines/reference/library_ArraySlice.types b/tests/baselines/reference/library_ArraySlice.types
index 1ff239e551d58..574ab69e3bbcc 100644
--- a/tests/baselines/reference/library_ArraySlice.types
+++ b/tests/baselines/reference/library_ArraySlice.types
@@ -6,7 +6,7 @@ Array.prototype.slice();
 >Array.prototype.slice() : any[]
 >                        : ^^^^^
 >Array.prototype.slice : (start?: number, end?: number) => any[]
->                      : ^     ^^^      ^^   ^^^      ^^^^^^^^  
+>                      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^
 >Array.prototype : any[]
 >                : ^^^^^
 >Array : ArrayConstructor
@@ -14,13 +14,13 @@ Array.prototype.slice();
 >prototype : any[]
 >          : ^^^^^
 >slice : (start?: number, end?: number) => any[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^
 
 Array.prototype.slice(0);
 >Array.prototype.slice(0) : any[]
 >                         : ^^^^^
 >Array.prototype.slice : (start?: number, end?: number) => any[]
->                      : ^     ^^^      ^^   ^^^      ^^^^^^^^  
+>                      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^
 >Array.prototype : any[]
 >                : ^^^^^
 >Array : ArrayConstructor
@@ -28,7 +28,7 @@ Array.prototype.slice(0);
 >prototype : any[]
 >          : ^^^^^
 >slice : (start?: number, end?: number) => any[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^
 >0 : 0
 >  : ^
 
@@ -36,7 +36,7 @@ Array.prototype.slice(0, 1);
 >Array.prototype.slice(0, 1) : any[]
 >                            : ^^^^^
 >Array.prototype.slice : (start?: number, end?: number) => any[]
->                      : ^     ^^^      ^^   ^^^      ^^^^^^^^  
+>                      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^
 >Array.prototype : any[]
 >                : ^^^^^
 >Array : ArrayConstructor
@@ -44,7 +44,7 @@ Array.prototype.slice(0, 1);
 >prototype : any[]
 >          : ^^^^^
 >slice : (start?: number, end?: number) => any[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^
 >0 : 0
 >  : ^
 >1 : 1
diff --git a/tests/baselines/reference/library_RegExpExecArraySlice.types b/tests/baselines/reference/library_RegExpExecArraySlice.types
index 7e80612e32faa..8a59c84086582 100644
--- a/tests/baselines/reference/library_RegExpExecArraySlice.types
+++ b/tests/baselines/reference/library_RegExpExecArraySlice.types
@@ -10,21 +10,21 @@ regExpExecArrayValue.slice();
 >regExpExecArrayValue.slice() : string[]
 >                             : ^^^^^^^^
 >regExpExecArrayValue.slice : (start?: number, end?: number) => string[]
->                           : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>                           : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >regExpExecArrayValue : RegExpExecArray
 >                     : ^^^^^^^^^^^^^^^
 >slice : (start?: number, end?: number) => string[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 
 regExpExecArrayValue.slice(0);
 >regExpExecArrayValue.slice(0) : string[]
 >                              : ^^^^^^^^
 >regExpExecArrayValue.slice : (start?: number, end?: number) => string[]
->                           : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>                           : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >regExpExecArrayValue : RegExpExecArray
 >                     : ^^^^^^^^^^^^^^^
 >slice : (start?: number, end?: number) => string[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 
@@ -32,11 +32,11 @@ regExpExecArrayValue.slice(0,1);
 >regExpExecArrayValue.slice(0,1) : string[]
 >                                : ^^^^^^^^
 >regExpExecArrayValue.slice : (start?: number, end?: number) => string[]
->                           : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>                           : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >regExpExecArrayValue : RegExpExecArray
 >                     : ^^^^^^^^^^^^^^^
 >slice : (start?: number, end?: number) => string[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 >1 : 1
diff --git a/tests/baselines/reference/listFailure.types b/tests/baselines/reference/listFailure.types
index 1fbd3a017e557..ee4b68baf1b00 100644
--- a/tests/baselines/reference/listFailure.types
+++ b/tests/baselines/reference/listFailure.types
@@ -37,7 +37,7 @@ module Editor {
 >this.lines.add(line) : List<Line>
 >                     : ^^^^^^^^^^
 >this.lines.add : (data: Line) => List<Line>
->               : ^    ^^^^^^^^^^^     ^^^^ 
+>               : ^    ^^^^^^^^^^^^^^^^^^^^^
 >this.lines : List<Line>
 >           : ^^^^^^^^^^
 >this : this
@@ -45,7 +45,7 @@ module Editor {
 >lines : List<Line>
 >      : ^^^^^^^^^^
 >add : (data: Line) => List<Line>
->    : ^    ^^^^^^^^^^^     ^^^^ 
+>    : ^    ^^^^^^^^^^^^^^^^^^^^^
 >line : Line
 >     : ^^^^
 
diff --git a/tests/baselines/reference/literalTypeWidening.types b/tests/baselines/reference/literalTypeWidening.types
index 11740e3c1a498..8e766a39b6e11 100644
--- a/tests/baselines/reference/literalTypeWidening.types
+++ b/tests/baselines/reference/literalTypeWidening.types
@@ -660,11 +660,11 @@ const arr: Obj[] = langCodes.map(code => ({ code }))
 >langCodes.map(code => ({ code })) : { code: "fr" | "en" | "es" | "it" | "nl"; }[]
 >                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >langCodes.map : <U>(callbackfn: (value: "fr" | "en" | "es" | "it" | "nl", index: number, array: ("fr" | "en" | "es" | "it" | "nl")[]) => U, thisArg?: any) => U[]
->              : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>              : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >langCodes : ("fr" | "en" | "es" | "it" | "nl")[]
 >          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: "fr" | "en" | "es" | "it" | "nl", index: number, array: ("fr" | "en" | "es" | "it" | "nl")[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >code => ({ code }) : (code: "fr" | "en" | "es" | "it" | "nl") => { code: "fr" | "en" | "es" | "it" | "nl"; }
 >                   : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >code : "fr" | "en" | "es" | "it" | "nl"
diff --git a/tests/baselines/reference/literalTypes2.types b/tests/baselines/reference/literalTypes2.types
index 45b897c5e5584..2744be4c5f10b 100644
--- a/tests/baselines/reference/literalTypes2.types
+++ b/tests/baselines/reference/literalTypes2.types
@@ -1200,11 +1200,11 @@ function append<T>(a: T[], x: T): T[] {
 >a.slice() : T[]
 >          : ^^^
 >a.slice : (start?: number, end?: number) => T[]
->        : ^     ^^^      ^^   ^^^      ^^^^^^  
+>        : ^     ^^^      ^^   ^^^      ^^^^^^^^
 >a : T[]
 >  : ^^^
 >slice : (start?: number, end?: number) => T[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^
 
     result.push(x);
 >result.push(x) : number
diff --git a/tests/baselines/reference/mapOnTupleTypes01.types b/tests/baselines/reference/mapOnTupleTypes01.types
index e4f1508df740d..bfaea018e6fab 100644
--- a/tests/baselines/reference/mapOnTupleTypes01.types
+++ b/tests/baselines/reference/mapOnTupleTypes01.types
@@ -7,7 +7,7 @@ export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n);
 >[1, 2, 3, 4].map(n => n * n) : number[]
 >                             : ^^^^^^^^
 >[1, 2, 3, 4].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->                 : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                 : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1, 2, 3, 4] : number[]
 >             : ^^^^^^^^
 >1 : 1
@@ -19,7 +19,7 @@ export let mapOnLooseArrayLiteral = [1, 2, 3, 4].map(n => n * n);
 >4 : 4
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >n => n * n : (n: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >n : number
@@ -47,11 +47,11 @@ export let a = numTuple.map(x => x * x);
 >numTuple.map(x => x * x) : number[]
 >                         : ^^^^^^^^
 >numTuple.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->             : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>             : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >numTuple : [number]
 >         : ^^^^^^^^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >x => x * x : (x: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >x : number
@@ -101,11 +101,11 @@ export let b = numNum.map(n => n * n);
 >numNum.map(n => n * n) : number[]
 >                       : ^^^^^^^^
 >numNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->           : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>           : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >numNum : [number, number]
 >       : ^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >n => n * n : (n: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >n : number
@@ -123,11 +123,11 @@ export let c = strStr.map(s => s.charCodeAt(0));
 >strStr.map(s => s.charCodeAt(0)) : number[]
 >                                 : ^^^^^^^^
 >strStr.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->           : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>           : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >strStr : [string, string]
 >       : ^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >s => s.charCodeAt(0) : (s: string) => number
 >                     : ^ ^^^^^^^^^^^^^^^^^^^
 >s : string
@@ -149,11 +149,11 @@ export let d = numStr.map(x => x);
 >numStr.map(x => x) : (string | number)[]
 >                   : ^^^^^^^^^^^^^^^^^^^
 >numStr.map : <U>(callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any) => U[]
->           : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>           : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >numStr : [number, string]
 >       : ^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: string | number, index: number, array: (string | number)[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >x => x : (x: string | number) => string | number
 >       : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : string | number
@@ -181,11 +181,11 @@ export let e = numNumNum.map(n => n * n);
 >numNumNum.map(n => n * n) : number[]
 >                          : ^^^^^^^^
 >numNumNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->              : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>              : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >numNumNum : [number, number, number]
 >          : ^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >n => n * n : (n: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >n : number
@@ -219,11 +219,11 @@ export let f = numNumNumNum.map(n => n * n);
 >numNumNumNum.map(n => n * n) : number[]
 >                             : ^^^^^^^^
 >numNumNumNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->                 : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                 : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >numNumNumNum : [number, number, number, number]
 >             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >n => n * n : (n: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >n : number
@@ -259,11 +259,11 @@ export let g = numNumNumNumNum.map(n => n * n);
 >numNumNumNumNum.map(n => n * n) : number[]
 >                                : ^^^^^^^^
 >numNumNumNumNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->                    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >numNumNumNumNum : [number, number, number, number, number]
 >                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >n => n * n : (n: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >n : number
@@ -302,11 +302,11 @@ export let h = numNumNumNumNum.map(n => n * n);
 >numNumNumNumNum.map(n => n * n) : number[]
 >                                : ^^^^^^^^
 >numNumNumNumNum.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->                    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >numNumNumNumNum : [number, number, number, number, number]
 >                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >n => n * n : (n: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >n : number
diff --git a/tests/baselines/reference/mapOnTupleTypes02.types b/tests/baselines/reference/mapOnTupleTypes02.types
index 9b03a59e4aa7c..8418460659903 100644
--- a/tests/baselines/reference/mapOnTupleTypes02.types
+++ b/tests/baselines/reference/mapOnTupleTypes02.types
@@ -15,11 +15,11 @@ export function increment(point: Point) {
 >point.map(d => d + 1) : number[]
 >                      : ^^^^^^^^
 >point.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->          : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>          : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >point : Point
 >      : ^^^^^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >d => d + 1 : (d: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >d : number
diff --git a/tests/baselines/reference/mappedTypeIndexedAccessConstraint.types b/tests/baselines/reference/mappedTypeIndexedAccessConstraint.types
index bed8d769bb832..7e40323959a29 100644
--- a/tests/baselines/reference/mappedTypeIndexedAccessConstraint.types
+++ b/tests/baselines/reference/mappedTypeIndexedAccessConstraint.types
@@ -191,8 +191,8 @@ type PartMappings = SetOptional<Mappings, "foo">;
 >             : ^^^^^^^^^^^^
 
 const mapper: { [K in keyof PartMappings]: (o: MapperArgs<K>) => PartMappings[K] } = {
->mapper : { "12": (o: MapperArgs<"12">) => PartMappings["12"]; 42: (o: MapperArgs<42>) => PartMappings[42]; foo?: ((o: MapperArgs<"foo">) => PartMappings["foo"]) | undefined; }
->       : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^             ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^ ^^^^^^^^^^^^^^^^
+>mapper : { "12": (o: MapperArgs<"12">) => number; 42: (o: MapperArgs<42>) => string; foo?: ((o: MapperArgs<"foo">) => boolean | undefined) | undefined; }
+>       : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >o : MapperArgs<K>
 >  : ^^^^^^^^^^^^^
 >{    foo: ({ v, i }) => v.length + i > 4,    "12": ({ v, i }) => Number(v) + i,    42: ({ v, i }) => `${v}${i}`,} : { foo: ({ v, i }: MapperArgs<"foo">) => boolean; "12": ({ v, i }: MapperArgs<"12">) => number; 42: ({ v, i }: MapperArgs<42>) => string; }
@@ -264,8 +264,8 @@ const resolveMapper1 = <K extends keyof typeof mapper>(
 >               : ^ ^^^^^^^^^                   ^^   ^^ ^^ ^^             ^^^^^^^^^^^^^^^^^^^^
 ><K extends keyof typeof mapper>(    key: K, o: MapperArgs<K>) => mapper[key](o) : <K extends keyof typeof mapper>(key: K, o: MapperArgs<K>) => PartMappings[K]
 >                                                                                : ^ ^^^^^^^^^                   ^^   ^^ ^^ ^^             ^^^^^^^^^^^^^^^^^^^^
->mapper : { "12": (o: MapperArgs<"12">) => PartMappings["12"]; 42: (o: MapperArgs<42>) => PartMappings[42]; foo?: ((o: MapperArgs<"foo">) => PartMappings["foo"]) | undefined; }
->       : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^             ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^ ^^^^^^^^^^^^^^^^
+>mapper : { "12": (o: MapperArgs<"12">) => number; 42: (o: MapperArgs<42>) => string; foo?: ((o: MapperArgs<"foo">) => boolean | undefined) | undefined; }
+>       : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     key: K, o: MapperArgs<K>) => mapper[key](o);  // Error
 >key : K
@@ -275,9 +275,9 @@ const resolveMapper1 = <K extends keyof typeof mapper>(
 >mapper[key](o) : PartMappings[K]
 >               : ^^^^^^^^^^^^^^^
 >mapper[key] : ((o: MapperArgs<K>) => PartMappings[K]) | undefined
->            : ^^ ^^^^^^^^^^^^^^^^^^^^             ^ ^^^^^^^^^^^^^
->mapper : { "12": (o: MapperArgs<"12">) => PartMappings["12"]; 42: (o: MapperArgs<42>) => PartMappings[42]; foo?: ((o: MapperArgs<"foo">) => PartMappings["foo"]) | undefined; }
->       : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^             ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^ ^^^^^^^^^^^^^^^^
+>            : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>mapper : { "12": (o: MapperArgs<"12">) => number; 42: (o: MapperArgs<42>) => string; foo?: ((o: MapperArgs<"foo">) => boolean | undefined) | undefined; }
+>       : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >key : K
 >    : ^
 >o : MapperArgs<K>
@@ -288,8 +288,8 @@ const resolveMapper2 = <K extends keyof typeof mapper>(
 >               : ^ ^^^^^^^^^                   ^^   ^^ ^^ ^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ><K extends keyof typeof mapper>(    key: K, o: MapperArgs<K>) => mapper[key]?.(o) : <K extends keyof typeof mapper>(key: K, o: MapperArgs<K>) => PartMappings[K] | undefined
 >                                                                                  : ^ ^^^^^^^^^                   ^^   ^^ ^^ ^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->mapper : { "12": (o: MapperArgs<"12">) => PartMappings["12"]; 42: (o: MapperArgs<42>) => PartMappings[42]; foo?: ((o: MapperArgs<"foo">) => PartMappings["foo"]) | undefined; }
->       : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^             ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^ ^^^^^^^^^^^^^^^^
+>mapper : { "12": (o: MapperArgs<"12">) => number; 42: (o: MapperArgs<42>) => string; foo?: ((o: MapperArgs<"foo">) => boolean | undefined) | undefined; }
+>       : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     key: K, o: MapperArgs<K>) => mapper[key]?.(o)
 >key : K
@@ -299,9 +299,9 @@ const resolveMapper2 = <K extends keyof typeof mapper>(
 >mapper[key]?.(o) : PartMappings[K] | undefined
 >                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >mapper[key] : ((o: MapperArgs<K>) => PartMappings[K]) | undefined
->            : ^^ ^^^^^^^^^^^^^^^^^^^^             ^ ^^^^^^^^^^^^^
->mapper : { "12": (o: MapperArgs<"12">) => PartMappings["12"]; 42: (o: MapperArgs<42>) => PartMappings[42]; foo?: ((o: MapperArgs<"foo">) => PartMappings["foo"]) | undefined; }
->       : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^             ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^ ^^^^^^^^^^^^^^^^
+>            : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>mapper : { "12": (o: MapperArgs<"12">) => number; 42: (o: MapperArgs<42>) => string; foo?: ((o: MapperArgs<"foo">) => boolean | undefined) | undefined; }
+>       : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >key : K
 >    : ^
 >o : MapperArgs<K>
diff --git a/tests/baselines/reference/mappedTypeNestedGenericInstantiation.types b/tests/baselines/reference/mappedTypeNestedGenericInstantiation.types
index 534ec3b3a4d30..f049a463f7332 100644
--- a/tests/baselines/reference/mappedTypeNestedGenericInstantiation.types
+++ b/tests/baselines/reference/mappedTypeNestedGenericInstantiation.types
@@ -46,8 +46,8 @@ const v = chain({a: 1, b: 2}).mapValues(square).value();
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >chain({a: 1, b: 2}).mapValues(square) : Chainable<{ a: number; b: number; }>
 >                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->chain({a: 1, b: 2}).mapValues : <U>(func: (v: number) => U) => Chainable<{ [k in "a" | "b"]: U; }>
->                              : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^                  ^^^^^^^^^   ^    
+>chain({a: 1, b: 2}).mapValues : <U>(func: (v: number) => U) => Chainable<{ a: U; b: U; }>
+>                              : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >chain({a: 1, b: 2}) : Chainable<{ a: number; b: number; }>
 >                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >chain : <T>(t: T) => Chainable<T>
@@ -62,8 +62,8 @@ const v = chain({a: 1, b: 2}).mapValues(square).value();
 >  : ^^^^^^
 >2 : 2
 >  : ^
->mapValues : <U>(func: (v: number) => U) => Chainable<{ [k in "a" | "b"]: U; }>
->          : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^                  ^^^^^^^^^   ^    
+>mapValues : <U>(func: (v: number) => U) => Chainable<{ a: U; b: U; }>
+>          : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >square : (x: number) => number
 >       : ^ ^^      ^^^^^^^^^^^
 >value : () => { a: number; b: number; }
diff --git a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.types b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.types
index d05367f5bb432..5297e055ec2ac 100644
--- a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.types
+++ b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.types
@@ -6,14 +6,14 @@ declare let tgt2: number[];
 >     : ^^^^^^^^
 
 declare let src2: { [K in keyof number[] as Exclude<K, "length">]: (number[])[K] };
->src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number | undefined; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number | undefined; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator<number>; values: () => IterableIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => IterableIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^  ^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^  ^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                          ^^^^^^  ^^^^^^^^^^^^^^                        ^^^^^^^^^^^^^^^^                 ^^^^^^ ^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^                 ^ ^^       ^^^^^^^^^^^^^  ^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^          ^  ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator<number>; values: () => IterableIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => IterableIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 tgt2 = src2; // Should error
->tgt2 = src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number | undefined; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number | undefined; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator<number>; values: () => IterableIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => IterableIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
->            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^  ^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^  ^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                          ^^^^^^  ^^^^^^^^^^^^^^                        ^^^^^^^^^^^^^^^^                 ^^^^^^ ^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^                 ^ ^^       ^^^^^^^^^^^^^  ^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^          ^  ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>tgt2 = src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator<number>; values: () => IterableIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => IterableIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >tgt2 : number[]
 >     : ^^^^^^^^
->src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number | undefined; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number | undefined; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator<number>; values: () => IterableIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => IterableIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^  ^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^  ^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                          ^^^^^^  ^^^^^^^^^^^^^^                        ^^^^^^^^^^^^^^^^                 ^^^^^^ ^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^                 ^ ^^       ^^^^^^^^^^^^^  ^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^          ^  ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator<number>; values: () => IterableIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => IterableIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.js b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.js
index 819790a7e7413..b143900a08085 100644
--- a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.js
+++ b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.js
@@ -16,7 +16,7 @@ export declare const thing: {
         (): string;
         (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
     };
-    pop: () => number | undefined;
+    pop: () => number;
     push: (...items: number[]) => number;
     concat: {
         (...items: ConcatArray<number>[]): number[];
@@ -24,7 +24,7 @@ export declare const thing: {
     };
     join: (separator?: string) => string;
     reverse: () => number[];
-    shift: () => number | undefined;
+    shift: () => number;
     slice: (start?: number, end?: number) => number[];
     sort: (compareFn?: (a: number, b: number) => number) => number[];
     splice: {
@@ -56,8 +56,8 @@ export declare const thing: {
         <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U;
     };
     find: {
-        <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined;
-        (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined;
+        <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S;
+        (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number;
     };
     findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number;
     fill: (value: number, start?: number, end?: number) => number[];
@@ -66,7 +66,7 @@ export declare const thing: {
     keys: () => IterableIterator<number>;
     values: () => IterableIterator<number>;
     includes: (searchElement: number, fromIndex?: number) => boolean;
-    flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[];
+    flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[];
     flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[];
     [Symbol.iterator]: () => IterableIterator<number>;
     readonly [Symbol.unscopables]: {
@@ -123,7 +123,7 @@ mappedTypeWithAsClauseAndLateBoundProperty2.d.ts(27,118): error TS2526: A 'this'
             (): string;
             (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
         };
-        pop: () => number | undefined;
+        pop: () => number;
         push: (...items: number[]) => number;
         concat: {
             (...items: ConcatArray<number>[]): number[];
@@ -131,7 +131,7 @@ mappedTypeWithAsClauseAndLateBoundProperty2.d.ts(27,118): error TS2526: A 'this'
         };
         join: (separator?: string) => string;
         reverse: () => number[];
-        shift: () => number | undefined;
+        shift: () => number;
         slice: (start?: number, end?: number) => number[];
         sort: (compareFn?: (a: number, b: number) => number) => number[];
         splice: {
@@ -165,8 +165,8 @@ mappedTypeWithAsClauseAndLateBoundProperty2.d.ts(27,118): error TS2526: A 'this'
             <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U;
         };
         find: {
-            <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined;
-            (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined;
+            <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S;
+            (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number;
         };
         findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number;
         fill: (value: number, start?: number, end?: number) => number[];
@@ -175,7 +175,7 @@ mappedTypeWithAsClauseAndLateBoundProperty2.d.ts(27,118): error TS2526: A 'this'
         keys: () => IterableIterator<number>;
         values: () => IterableIterator<number>;
         includes: (searchElement: number, fromIndex?: number) => boolean;
-        flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[];
+        flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[];
         flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[];
         [Symbol.iterator]: () => IterableIterator<number>;
         readonly [Symbol.unscopables]: {
diff --git a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.types b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.types
index 9f063b00abfe7..a58dddd838214 100644
--- a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.types
+++ b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.types
@@ -2,11 +2,11 @@
 
 === mappedTypeWithAsClauseAndLateBoundProperty2.ts ===
 export const thing = (null as any as { [K in keyof number[] as Exclude<K, "length">]: (number[])[K] });
->thing : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number | undefined; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number | undefined; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator<number>; values: () => IterableIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => IterableIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^  ^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^  ^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                          ^^^^^^  ^^^^^^^^^^^^^^                        ^^^^^^^^^^^^^^^^                 ^^^^^^ ^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^                 ^ ^^       ^^^^^^^^^^^^^  ^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^          ^  ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->(null as any as { [K in keyof number[] as Exclude<K, "length">]: (number[])[K] }) : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number | undefined; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number | undefined; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator<number>; values: () => IterableIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => IterableIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
->                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^  ^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^  ^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                          ^^^^^^  ^^^^^^^^^^^^^^                        ^^^^^^^^^^^^^^^^                 ^^^^^^ ^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^                 ^ ^^       ^^^^^^^^^^^^^  ^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^          ^  ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->null as any as { [K in keyof number[] as Exclude<K, "length">]: (number[])[K] } : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number | undefined; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number | undefined; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator<number>; values: () => IterableIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => IterableIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
->                                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^  ^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^  ^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                          ^^^^^^  ^^^^^^^^^^^^^^                        ^^^^^^^^^^^^^^^^                 ^^^^^^ ^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^                 ^ ^^       ^^^^^^^^^^^^^  ^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^          ^  ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>thing : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator<number>; values: () => IterableIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => IterableIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>(null as any as { [K in keyof number[] as Exclude<K, "length">]: (number[])[K] }) : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator<number>; values: () => IterableIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => IterableIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
+>                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>null as any as { [K in keyof number[] as Exclude<K, "length">]: (number[])[K] } : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => IterableIterator<[number, number]>; keys: () => IterableIterator<number>; values: () => IterableIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => IterableIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
+>                                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >null as any : any
 
diff --git a/tests/baselines/reference/mappedTypesArraysTuples.types b/tests/baselines/reference/mappedTypesArraysTuples.types
index 86f10e80f016c..5f2dc69223c9e 100644
--- a/tests/baselines/reference/mappedTypesArraysTuples.types
+++ b/tests/baselines/reference/mappedTypesArraysTuples.types
@@ -314,11 +314,11 @@ function f2<T extends any[]>(a: Boxified<T>) {
 >a.pop() : Box<any> | undefined
 >        : ^^^^^^^^^^^^^^^^^^^^
 >a.pop : () => Box<any> | undefined
->      : ^^^^^^^^^^^^^^            
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a : Boxified<T>
 >  : ^^^^^^^^^^^
 >pop : () => Box<any> | undefined
->    : ^^^^^^^^^^^^^^            
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     let y: Box<any>[] = a.concat(a);
 >y : Box<any>[]
@@ -326,11 +326,11 @@ function f2<T extends any[]>(a: Boxified<T>) {
 >a.concat(a) : Box<any>[]
 >            : ^^^^^^^^^^
 >a.concat : { (...items: ConcatArray<Box<any>>[]): Box<any>[]; (...items: (Box<any> | ConcatArray<Box<any>>)[]): Box<any>[]; }
->         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a : Boxified<T>
 >  : ^^^^^^^^^^^
 >concat : { (...items: ConcatArray<Box<any>>[]): Box<any>[]; (...items: (Box<any> | ConcatArray<Box<any>>)[]): Box<any>[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a : Boxified<T>
 >  : ^^^^^^^^^^^
 }
diff --git a/tests/baselines/reference/mappedTypesGenericTuples2.types b/tests/baselines/reference/mappedTypesGenericTuples2.types
index a48a2f75e3dfa..07694eba180f6 100644
--- a/tests/baselines/reference/mappedTypesGenericTuples2.types
+++ b/tests/baselines/reference/mappedTypesGenericTuples2.types
@@ -11,7 +11,7 @@ Promise.all([getT<string>(), ...getT<any>()]).then((result) => {
 >Promise.all([getT<string>(), ...getT<any>()]).then((result) => {  const head = result[0]; // string  const tail = result.slice(1); // any[]  tail satisfies string[]; // ok}) : Promise<void>
 >                                                                                                                                                                              : ^^^^^^^^^^^^^
 >Promise.all([getT<string>(), ...getT<any>()]).then : <TResult1 = [string, ...any[]], TResult2 = never>(onfulfilled?: ((value: [string, ...any[]]) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->                                                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                                                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Promise.all([getT<string>(), ...getT<any>()]) : Promise<[string, ...any[]]>
 >                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Promise.all : { <T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>; <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>; }
@@ -31,7 +31,7 @@ Promise.all([getT<string>(), ...getT<any>()]).then((result) => {
 >getT : <T>() => T
 >     : ^ ^^^^^^^ 
 >then : <TResult1 = [string, ...any[]], TResult2 = never>(onfulfilled?: ((value: [string, ...any[]]) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(result) => {  const head = result[0]; // string  const tail = result.slice(1); // any[]  tail satisfies string[]; // ok} : (result: [string, ...any[]]) => void
 >                                                                                                                          : ^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >result : [string, ...any[]]
@@ -53,11 +53,11 @@ Promise.all([getT<string>(), ...getT<any>()]).then((result) => {
 >result.slice(1) : any[]
 >                : ^^^^^
 >result.slice : (start?: number, end?: number) => any[]
->             : ^     ^^^      ^^   ^^^      ^^^^^^^^  
+>             : ^     ^^^      ^^   ^^^      ^^^^^^^^^^
 >result : [string, ...any[]]
 >       : ^^^^^^^^^^^^^^^^^^
 >slice : (start?: number, end?: number) => any[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^
 >1 : 1
 >  : ^
 
diff --git a/tests/baselines/reference/modularizeLibrary_Dom.asynciterable.types b/tests/baselines/reference/modularizeLibrary_Dom.asynciterable.types
index cf18b4ad66a1a..999ee253d4e18 100644
--- a/tests/baselines/reference/modularizeLibrary_Dom.asynciterable.types
+++ b/tests/baselines/reference/modularizeLibrary_Dom.asynciterable.types
@@ -5,7 +5,7 @@ navigator.storage.getDirectory().then(async directory => {
 >navigator.storage.getDirectory().then(async directory => {    for await (const [key, handle] of directory) {        handle.kind;    }}) : Promise<void>
 >                                                                                                                                        : ^^^^^^^^^^^^^
 >navigator.storage.getDirectory().then : <TResult1 = FileSystemDirectoryHandle, TResult2 = never>(onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                                      : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                                      : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >navigator.storage.getDirectory() : Promise<FileSystemDirectoryHandle>
 >                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >navigator.storage.getDirectory : () => Promise<FileSystemDirectoryHandle>
@@ -19,7 +19,7 @@ navigator.storage.getDirectory().then(async directory => {
 >getDirectory : () => Promise<FileSystemDirectoryHandle>
 >             : ^^^^^^                                  
 >then : <TResult1 = FileSystemDirectoryHandle, TResult2 = never>(onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >async directory => {    for await (const [key, handle] of directory) {        handle.kind;    }} : (directory: FileSystemDirectoryHandle) => Promise<void>
 >                                                                                                 : ^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >directory : FileSystemDirectoryHandle
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
index e95c501d8beca..79250a582cd45 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
@@ -61,11 +61,11 @@ m.keys();
 >m.keys() : IterableIterator<string>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^
 >m.keys : () => IterableIterator<string>
->       : ^^^^^^                 ^^^^^^ 
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >m : Map<string, number>
 >  : ^^^^^^^^^^^^^^^^^^^
 >keys : () => IterableIterator<string>
->     : ^^^^^^                 ^^^^^^ 
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 // Using ES6 function
 function Baz() { }
@@ -226,13 +226,13 @@ out().then(() => {
 >out().then(() => {    console.log("Yea!");}) : Promise<void>
 >                                             : ^^^^^^^^^^^^^
 >out().then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->           : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>           : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >out() : Promise<unknown>
 >      : ^^^^^^^^^^^^^^^^
 >out : () => Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {    console.log("Yea!");} : () => void
 >                                 : ^^^^^^^^^^
 
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
index 9c1a8cf879f2f..55d4b9bcb32fc 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
@@ -61,11 +61,11 @@ m.keys();
 >m.keys() : IterableIterator<string>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^
 >m.keys : () => IterableIterator<string>
->       : ^^^^^^                 ^^^^^^ 
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >m : Map<string, number>
 >  : ^^^^^^^^^^^^^^^^^^^
 >keys : () => IterableIterator<string>
->     : ^^^^^^                 ^^^^^^ 
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 // Using ES6 function
 function Baz() { }
@@ -226,13 +226,13 @@ out().then(() => {
 >out().then(() => {    console.log("Yea!");}) : Promise<void>
 >                                             : ^^^^^^^^^^^^^
 >out().then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->           : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>           : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >out() : Promise<unknown>
 >      : ^^^^^^^^^^^^^^^^
 >out : () => Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {    console.log("Yea!");} : () => void
 >                                 : ^^^^^^^^^^
 
diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
index 66a7d6daba011..a8e7094e15925 100644
--- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
+++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
@@ -61,11 +61,11 @@ m.keys();
 >m.keys() : IterableIterator<string>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^
 >m.keys : () => IterableIterator<string>
->       : ^^^^^^                 ^^^^^^ 
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >m : Map<string, number>
 >  : ^^^^^^^^^^^^^^^^^^^
 >keys : () => IterableIterator<string>
->     : ^^^^^^                 ^^^^^^ 
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 // Using ES6 function
 function Baz() { }
@@ -226,13 +226,13 @@ out().then(() => {
 >out().then(() => {    console.log("Yea!");}) : Promise<void>
 >                                             : ^^^^^^^^^^^^^
 >out().then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->           : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>           : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >out() : Promise<unknown>
 >      : ^^^^^^^^^^^^^^^^
 >out : () => Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {    console.log("Yea!");} : () => void
 >                                 : ^^^^^^^^^^
 
diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types
index 05dc79e9bd2b1..cb5bfa219fe72 100644
--- a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types
+++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types
@@ -61,11 +61,11 @@ m.keys();
 >m.keys() : IterableIterator<string>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^
 >m.keys : () => IterableIterator<string>
->       : ^^^^^^                 ^^^^^^ 
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >m : Map<string, number>
 >  : ^^^^^^^^^^^^^^^^^^^
 >keys : () => IterableIterator<string>
->     : ^^^^^^                 ^^^^^^ 
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 // Using ES6 function
 function Baz() { }
diff --git a/tests/baselines/reference/modularizeLibrary_Worker.asynciterable.types b/tests/baselines/reference/modularizeLibrary_Worker.asynciterable.types
index a5e302d0d80a5..3e3e22f19a77a 100644
--- a/tests/baselines/reference/modularizeLibrary_Worker.asynciterable.types
+++ b/tests/baselines/reference/modularizeLibrary_Worker.asynciterable.types
@@ -5,7 +5,7 @@ navigator.storage.getDirectory().then(async directory => {
 >navigator.storage.getDirectory().then(async directory => {    for await (const [key, handle] of directory) {        handle.kind;    }}) : Promise<void>
 >                                                                                                                                        : ^^^^^^^^^^^^^
 >navigator.storage.getDirectory().then : <TResult1 = FileSystemDirectoryHandle, TResult2 = never>(onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                                      : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                                      : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >navigator.storage.getDirectory() : Promise<FileSystemDirectoryHandle>
 >                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >navigator.storage.getDirectory : () => Promise<FileSystemDirectoryHandle>
@@ -19,7 +19,7 @@ navigator.storage.getDirectory().then(async directory => {
 >getDirectory : () => Promise<FileSystemDirectoryHandle>
 >             : ^^^^^^                                  
 >then : <TResult1 = FileSystemDirectoryHandle, TResult2 = never>(onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >async directory => {    for await (const [key, handle] of directory) {        handle.kind;    }} : (directory: FileSystemDirectoryHandle) => Promise<void>
 >                                                                                                 : ^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >directory : FileSystemDirectoryHandle
diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.types b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.types
index 5aa3935a4c920..02894825deea0 100644
--- a/tests/baselines/reference/moduleAugmentationDeclarationEmit1.types
+++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit1.types
@@ -87,11 +87,11 @@ let y = x.map(x => x + 1);
 >x.map(x => x + 1) : Observable<number>
 >                  : ^^^^^^^^^^^^^^^^^^
 >x.map : <U>(proj: (e: number) => U) => Observable<U>
->      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : Observable<number>
 >  : ^^^^^^^^^^^^^^^^^^
 >map : <U>(proj: (e: number) => U) => Observable<U>
->    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x + 1 : (x: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >x : number
diff --git a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.types b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.types
index e04bdb53d1532..c671eff75e970 100644
--- a/tests/baselines/reference/moduleAugmentationDeclarationEmit2.types
+++ b/tests/baselines/reference/moduleAugmentationDeclarationEmit2.types
@@ -87,11 +87,11 @@ let y = x.map(x => x + 1);
 >x.map(x => x + 1) : Observable<number>
 >                  : ^^^^^^^^^^^^^^^^^^
 >x.map : <U>(proj: (e: number) => U) => Observable<U>
->      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : Observable<number>
 >  : ^^^^^^^^^^^^^^^^^^
 >map : <U>(proj: (e: number) => U) => Observable<U>
->    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x + 1 : (x: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >x : number
diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.types b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.types
index 90f67f85953d8..23976fa62fa1f 100644
--- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.types
+++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule1.types
@@ -18,11 +18,11 @@ let y = x.map(x => x + 1);
 >x.map(x => x + 1) : Observable<number>
 >                  : ^^^^^^^^^^^^^^^^^^
 >x.map : <U>(proj: (e: number) => U) => Observable<U>
->      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : Observable<number>
 >  : ^^^^^^^^^^^^^^^^^^
 >map : <U>(proj: (e: number) => U) => Observable<U>
->    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x + 1 : (x: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >x : number
diff --git a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.types b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.types
index 08acbf0d14de4..434b082c35334 100644
--- a/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.types
+++ b/tests/baselines/reference/moduleAugmentationExtendAmbientModule2.types
@@ -18,11 +18,11 @@ let y = x.map(x => x + 1);
 >x.map(x => x + 1) : Observable<number>
 >                  : ^^^^^^^^^^^^^^^^^^
 >x.map : <U>(proj: (e: number) => U) => Observable<U>
->      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : Observable<number>
 >  : ^^^^^^^^^^^^^^^^^^
 >map : <U>(proj: (e: number) => U) => Observable<U>
->    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x + 1 : (x: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >x : number
diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule1.types b/tests/baselines/reference/moduleAugmentationExtendFileModule1.types
index 7d8de40ad96d0..edfac768b8ba5 100644
--- a/tests/baselines/reference/moduleAugmentationExtendFileModule1.types
+++ b/tests/baselines/reference/moduleAugmentationExtendFileModule1.types
@@ -87,11 +87,11 @@ let y = x.map(x => x + 1);
 >x.map(x => x + 1) : Observable<number>
 >                  : ^^^^^^^^^^^^^^^^^^
 >x.map : <U>(proj: (e: number) => U) => Observable<U>
->      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : Observable<number>
 >  : ^^^^^^^^^^^^^^^^^^
 >map : <U>(proj: (e: number) => U) => Observable<U>
->    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x + 1 : (x: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >x : number
diff --git a/tests/baselines/reference/moduleAugmentationExtendFileModule2.types b/tests/baselines/reference/moduleAugmentationExtendFileModule2.types
index be1be80d4b5e2..d4fe768fc7874 100644
--- a/tests/baselines/reference/moduleAugmentationExtendFileModule2.types
+++ b/tests/baselines/reference/moduleAugmentationExtendFileModule2.types
@@ -87,11 +87,11 @@ let y = x.map(x => x + 1);
 >x.map(x => x + 1) : Observable<number>
 >                  : ^^^^^^^^^^^^^^^^^^
 >x.map : <U>(proj: (e: number) => U) => Observable<U>
->      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : Observable<number>
 >  : ^^^^^^^^^^^^^^^^^^
 >map : <U>(proj: (e: number) => U) => Observable<U>
->    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x + 1 : (x: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >x : number
diff --git a/tests/baselines/reference/moduleAugmentationNoNewNames.types b/tests/baselines/reference/moduleAugmentationNoNewNames.types
index 6a8262c8a5367..0e7be89f26576 100644
--- a/tests/baselines/reference/moduleAugmentationNoNewNames.types
+++ b/tests/baselines/reference/moduleAugmentationNoNewNames.types
@@ -94,11 +94,11 @@ let y = x.map(x => x + 1);
 >x.map(x => x + 1) : Observable<number>
 >                  : ^^^^^^^^^^^^^^^^^^
 >x.map : <U>(proj: (e: number) => U) => Observable<U>
->      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>      : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : Observable<number>
 >  : ^^^^^^^^^^^^^^^^^^
 >map : <U>(proj: (e: number) => U) => Observable<U>
->    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^           ^ 
+>    : ^ ^^    ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x + 1 : (x: number) => number
 >           : ^ ^^^^^^^^^^^^^^^^^^^
 >x : number
diff --git a/tests/baselines/reference/moduleResolutionWithoutExtension5.types b/tests/baselines/reference/moduleResolutionWithoutExtension5.types
index 412bf79718f9f..50d45cebb23dc 100644
--- a/tests/baselines/reference/moduleResolutionWithoutExtension5.types
+++ b/tests/baselines/reference/moduleResolutionWithoutExtension5.types
@@ -6,13 +6,13 @@ import("./foo").then(x => x); // should error, ask for extension
 >import("./foo").then(x => x) : Promise<any>
 >                             : ^^^^^^^^^^^^
 >import("./foo").then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >import("./foo") : Promise<any>
 >                : ^^^^^^^^^^^^
 >"./foo" : "./foo"
 >        : ^^^^^^^
 >then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x : (x: any) => any
 >       : ^ ^^^^^^^^^^^^^
 >x : any
diff --git a/tests/baselines/reference/moduleResolutionWithoutExtension8.types b/tests/baselines/reference/moduleResolutionWithoutExtension8.types
index 1653c2c74ab6b..7e6332877585a 100644
--- a/tests/baselines/reference/moduleResolutionWithoutExtension8.types
+++ b/tests/baselines/reference/moduleResolutionWithoutExtension8.types
@@ -6,13 +6,13 @@ import("./foo").then(x => x); // should error, ask for extension
 >import("./foo").then(x => x) : Promise<any>
 >                             : ^^^^^^^^^^^^
 >import("./foo").then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >import("./foo") : Promise<any>
 >                : ^^^^^^^^^^^^
 >"./foo" : "./foo"
 >        : ^^^^^^^
 >then : <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x : (x: any) => any
 >       : ^ ^^^^^^^^^^^^^
 >x : any
diff --git a/tests/baselines/reference/mutuallyRecursiveGenericBaseTypes1.types b/tests/baselines/reference/mutuallyRecursiveGenericBaseTypes1.types
index 4e21cefca6dfe..c47a3ad783e6e 100644
--- a/tests/baselines/reference/mutuallyRecursiveGenericBaseTypes1.types
+++ b/tests/baselines/reference/mutuallyRecursiveGenericBaseTypes1.types
@@ -29,11 +29,11 @@ b.foo(); // should not error
 >b.foo() : B<number>
 >        : ^^^^^^^^^
 >b.foo : { (): B<number>; (): void; }
->      : ^^^^^^  ^^^^^^ ^^^^^^    ^^^
+>      : ^^^^^^^^^^^^^^^^^^^^^    ^^^
 >b : B<number>
 >  : ^^^^^^^^^
 >foo : { (): B<number>; (): void; }
->    : ^^^^^^  ^^^^^^ ^^^^^^    ^^^
+>    : ^^^^^^^^^^^^^^^^^^^^^    ^^^
 
  
 
diff --git a/tests/baselines/reference/narrowingAssignmentReadonlyRespectsAssertion.types b/tests/baselines/reference/narrowingAssignmentReadonlyRespectsAssertion.types
index 51f63563fe28b..43415e124c617 100644
--- a/tests/baselines/reference/narrowingAssignmentReadonlyRespectsAssertion.types
+++ b/tests/baselines/reference/narrowingAssignmentReadonlyRespectsAssertion.types
@@ -180,17 +180,17 @@ function testFunc() {
 >val1.slice().reverse() : any[]
 >                       : ^^^^^
 >val1.slice().reverse : () => any[]
->                     : ^^^^^^^^^  
+>                     : ^^^^^^^^^^^
 >val1.slice() : any[]
 >             : ^^^^^
 >val1.slice : (start?: number, end?: number) => any[]
->           : ^     ^^^      ^^   ^^^      ^^^^^^^^  
+>           : ^     ^^^      ^^   ^^^      ^^^^^^^^^^
 >val1 : any[]
 >     : ^^^^^
 >slice : (start?: number, end?: number) => any[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^
 >reverse : () => any[]
->        : ^^^^^^^^^  
+>        : ^^^^^^^^^^^
 
           console.log(reversedVal1);
 >console.log(reversedVal1) : void
diff --git a/tests/baselines/reference/narrowingNoInfer1.types b/tests/baselines/reference/narrowingNoInfer1.types
index be4d1b1cf6e4a..690fcaa27be25 100644
--- a/tests/baselines/reference/narrowingNoInfer1.types
+++ b/tests/baselines/reference/narrowingNoInfer1.types
@@ -41,11 +41,11 @@ function map<A, B>(items: readonly A[], f: (a: NoInfer<A>) => B) {
 >items.map(f) : B[]
 >             : ^^^
 >items.map : <U>(callbackfn: (value: A, index: number, array: readonly A[]) => U, thisArg?: any) => U[]
->          : ^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>          : ^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >items : readonly A[]
 >      : ^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: A, index: number, array: readonly A[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >f : (a: NoInfer<A>) => B
 >  : ^ ^^          ^^^^^ 
 }
diff --git a/tests/baselines/reference/narrowingPastLastAssignment.types b/tests/baselines/reference/narrowingPastLastAssignment.types
index 8161272644be3..16513a09fdfe8 100644
--- a/tests/baselines/reference/narrowingPastLastAssignment.types
+++ b/tests/baselines/reference/narrowingPastLastAssignment.types
@@ -680,11 +680,11 @@ function f12() {
 >fooMap.get("a") : number[] | undefined
 >                : ^^^^^^^^^^^^^^^^^^^^
 >fooMap.get : (key: string) => number[] | undefined
->           : ^   ^^^^^^^^^^^^^^^^^^^^^            
+>           : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >fooMap : Map<string, number[]>
 >       : ^^^^^^^^^^^^^^^^^^^^^
 >get : (key: string) => number[] | undefined
->    : ^   ^^^^^^^^^^^^^^^^^^^^^            
+>    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >"a" : "a"
 >    : ^^^
 
diff --git a/tests/baselines/reference/nestedSelf.types b/tests/baselines/reference/nestedSelf.types
index 98b315c84c666..b676271d5113b 100644
--- a/tests/baselines/reference/nestedSelf.types
+++ b/tests/baselines/reference/nestedSelf.types
@@ -21,7 +21,7 @@ module M {
 >[1,2,3].map((x) => { return this.n * x; }) : number[]
 >                                           : ^^^^^^^^
 >[1,2,3].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->            : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>            : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1,2,3] : number[]
 >        : ^^^^^^^^
 >1 : 1
@@ -31,7 +31,7 @@ module M {
 >3 : 3
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(x) => { return this.n * x; } : (x: number) => number
 >                              : ^ ^^^^^^^^^^^^^^^^^^^
 >x : number
diff --git a/tests/baselines/reference/nonInferrableTypePropagation1.types b/tests/baselines/reference/nonInferrableTypePropagation1.types
index add4e2963d12b..2c0f4ffbab25b 100644
--- a/tests/baselines/reference/nonInferrableTypePropagation1.types
+++ b/tests/baselines/reference/nonInferrableTypePropagation1.types
@@ -84,11 +84,11 @@ const result1 = createAndUnbox(() => thing.pipe(
 >thing.pipe(    map((data) => box(data)),    tap((v) => log(v)),) : Thing<Box<number>>
 >                                                                 : ^^^^^^^^^^^^^^^^^^
 >thing.pipe : <A, B>(opA: Op<number, A>, opB: Op<A, B>) => Thing<B>
->           : ^ ^^ ^^   ^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^      ^ 
+>           : ^ ^^ ^^   ^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >thing : Thing<number>
 >      : ^^^^^^^^^^^^^
 >pipe : <A, B>(opA: Op<number, A>, opB: Op<A, B>) => Thing<B>
->     : ^ ^^ ^^   ^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^      ^ 
+>     : ^ ^^ ^^   ^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 
     map((data) => box(data)),
 >map((data) => box(data)) : Op<number, Box<number>>
@@ -136,11 +136,11 @@ const result2 = createAndUnbox(() => thing.pipe(
 >thing.pipe(    tap((v) => log(v)),    map((data) => box(data)),) : Thing<Box<number>>
 >                                                                 : ^^^^^^^^^^^^^^^^^^
 >thing.pipe : <A, B>(opA: Op<number, A>, opB: Op<A, B>) => Thing<B>
->           : ^ ^^ ^^   ^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^      ^ 
+>           : ^ ^^ ^^   ^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 >thing : Thing<number>
 >      : ^^^^^^^^^^^^^
 >pipe : <A, B>(opA: Op<number, A>, opB: Op<A, B>) => Thing<B>
->     : ^ ^^ ^^   ^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^      ^ 
+>     : ^ ^^ ^^   ^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^
 
     tap((v) => log(v)),
 >tap((v) => log(v)) : Op<number, number>
diff --git a/tests/baselines/reference/nonInferrableTypePropagation2.types b/tests/baselines/reference/nonInferrableTypePropagation2.types
index ba69f16136caf..c938c94e70002 100644
--- a/tests/baselines/reference/nonInferrableTypePropagation2.types
+++ b/tests/baselines/reference/nonInferrableTypePropagation2.types
@@ -92,8 +92,8 @@ const x = pipe(es, filter(exists((n) => n > 0)))
 >     : ^ ^^ ^^ ^^ ^^  ^^           ^^^^^ 
 >es : Either<string, number>[]
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^
->filter(exists((n) => n > 0)) : (as: readonly Either<string, number>[]) => ReadonlyArray<Either<string, number>>
->                             : ^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^              ^^^^^^^^^^^^^^^^^^^^^^ 
+>filter(exists((n) => n > 0)) : (as: readonly Either<string, number>[]) => readonly Either<string, number>[]
+>                             : ^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >filter : { <A, B extends A>(refinement: Refinement<A, B>): (as: ReadonlyArray<A>) => ReadonlyArray<B>; <A>(predicate: Predicate<A>): <B extends A>(bs: ReadonlyArray<B>) => ReadonlyArray<B>; <A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => ReadonlyArray<A>; }
 >       : ^^^ ^^ ^^^^^^^^^ ^^          ^^                ^^^                                          ^^^ ^^         ^^            ^^^                                                       ^^^ ^^         ^^            ^^^                                          ^^^
 >exists((n) => n > 0) : <E>(ma: Either<E, number>) => boolean
diff --git a/tests/baselines/reference/nonInferrableTypePropagation3.types b/tests/baselines/reference/nonInferrableTypePropagation3.types
index 1e942321a3730..7efbb45641053 100644
--- a/tests/baselines/reference/nonInferrableTypePropagation3.types
+++ b/tests/baselines/reference/nonInferrableTypePropagation3.types
@@ -21,9 +21,9 @@ declare function factory<Out>(): <Args extends any[], R>(callback: Callback<Args
 
 const make = factory<{id: string, age: number}[]>();
 >make : <Args extends any[], R>(callback: Callback<Args, { id: string; age: number; }[], R>) => (...args: Args) => R
->     : ^    ^^^^^^^^^     ^^ ^^        ^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^          ^^^^     ^
+>     : ^    ^^^^^^^^^     ^^ ^^        ^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^
 >factory<{id: string, age: number}[]>() : <Args extends any[], R>(callback: Callback<Args, { id: string; age: number; }[], R>) => (...args: Args) => R
->                                       : ^    ^^^^^^^^^     ^^ ^^        ^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^          ^^^^     ^
+>                                       : ^    ^^^^^^^^^     ^^ ^^        ^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^
 >factory : <Out>() => <Args extends any[], R>(callback: Callback<Args, Out, R>) => (...args: Args) => R
 >        : ^   ^^^^^^^                                                                                 
 >id : string
@@ -37,7 +37,7 @@ const usersOverAge = make((age: number) => data => {
 >make((age: number) => data => {    return data.filter(user => user.age >= age);}) : (age: number) => { id: string; age: number; }[]
 >                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^      ^^^^^
 >make : <Args extends any[], R>(callback: Callback<Args, { id: string; age: number; }[], R>) => (...args: Args) => R
->     : ^    ^^^^^^^^^     ^^ ^^        ^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^          ^^^^     ^
+>     : ^    ^^^^^^^^^     ^^ ^^        ^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^
 >(age: number) => data => {    return data.filter(user => user.age >= age);} : (age: number) => (data: { id: string; age: number; }[]) => { id: string; age: number; }[]
 >                                                                            : ^   ^^      ^^^^^^    ^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^^^      ^^^^^^^      ^^^^^
 >age : number
@@ -51,11 +51,11 @@ const usersOverAge = make((age: number) => data => {
 >data.filter(user => user.age >= age) : { id: string; age: number; }[]
 >                                     : ^^^^^^      ^^^^^^^      ^^^^^
 >data.filter : { <S extends { id: string; age: number; }>(predicate: (value: { id: string; age: number; }, index: number, array: { id: string; age: number; }[]) => value is S, thisArg?: any): S[]; (predicate: (value: { id: string; age: number; }, index: number, array: { id: string; age: number; }[]) => unknown, thisArg?: any): { id: string; age: number; }[]; }
->            : ^^^ ^^^^^^^^^^^^^^^      ^^^^^^^      ^^^^^         ^^^     ^^^^^^^^      ^^^^^^^      ^^^^^     ^^      ^^     ^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^      ^^^^^^^      ^^^^^     ^^      ^^     ^^^^^^^^      ^^^^^^^      ^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^      ^^^^^^^      ^^^  ^^^
+>            : ^^^ ^^^^^^^^^^^^^^^      ^^^^^^^      ^^^^^         ^^^     ^^^^^^^^      ^^^^^^^      ^^^^^     ^^      ^^     ^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^      ^^^^^^^      ^^^^^     ^^      ^^     ^^^^^^^^      ^^^^^^^      ^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^      ^^^^^^^      ^^^^^^^^
 >data : { id: string; age: number; }[]
 >     : ^^^^^^      ^^^^^^^      ^^^^^
 >filter : { <S extends { id: string; age: number; }>(predicate: (value: { id: string; age: number; }, index: number, array: { id: string; age: number; }[]) => value is S, thisArg?: any): S[]; (predicate: (value: { id: string; age: number; }, index: number, array: { id: string; age: number; }[]) => unknown, thisArg?: any): { id: string; age: number; }[]; }
->       : ^^^ ^^^^^^^^^^^^^^^      ^^^^^^^      ^^^^^         ^^^     ^^^^^^^^      ^^^^^^^      ^^^^^     ^^      ^^     ^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^      ^^^^^^^      ^^^^^     ^^      ^^     ^^^^^^^^      ^^^^^^^      ^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^      ^^^^^^^      ^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^      ^^^^^^^      ^^^^^         ^^^     ^^^^^^^^      ^^^^^^^      ^^^^^     ^^      ^^     ^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^      ^^^^^^^      ^^^^^     ^^      ^^     ^^^^^^^^      ^^^^^^^      ^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^      ^^^^^^^      ^^^^^^^^
 >user => user.age >= age : (user: { id: string; age: number; }) => boolean
 >                        : ^    ^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^^
 >user : { id: string; age: number; }
diff --git a/tests/baselines/reference/objectInstantiationFromUnionSpread.types b/tests/baselines/reference/objectInstantiationFromUnionSpread.types
index edd3e7fae0437..efe06587135d1 100644
--- a/tests/baselines/reference/objectInstantiationFromUnionSpread.types
+++ b/tests/baselines/reference/objectInstantiationFromUnionSpread.types
@@ -33,15 +33,15 @@ function f1(a: Item[]) {
 >a.map(item => ({ ...item })).filter(value => {}) : ({ isSuccess: true; } | { isSuccess: false; })[]
 >                                                 : ^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^
 >a.map(item => ({ ...item })).filter : { <S extends { isSuccess: true; } | { isSuccess: false; }>(predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => value is S, thisArg?: any): S[]; (predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => unknown, thisArg?: any): ({ isSuccess: true; } | { isSuccess: false; })[]; }
->                                    : ^^^ ^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^  ^^^
+>                                    : ^^^ ^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^
 >a.map(item => ({ ...item })) : ({ isSuccess: true; } | { isSuccess: false; })[]
 >                             : ^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^
 >a.map : <U>(callbackfn: (value: Item, index: number, array: Item[]) => U, thisArg?: any) => U[]
->      : ^ ^^          ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>      : ^ ^^          ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >a : Item[]
 >  : ^^^^^^
 >map : <U>(callbackfn: (value: Item, index: number, array: Item[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >item => ({ ...item }) : (item: Item) => { isSuccess: true; } | { isSuccess: false; }
 >                      : ^    ^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^
 >item : Item
@@ -53,7 +53,7 @@ function f1(a: Item[]) {
 >item : Item
 >     : ^^^^
 >filter : { <S extends { isSuccess: true; } | { isSuccess: false; }>(predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => value is S, thisArg?: any): S[]; (predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => unknown, thisArg?: any): ({ isSuccess: true; } | { isSuccess: false; })[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^
 >value => {} : (value: { isSuccess: true; } | { isSuccess: false; }) => void
 >            : ^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^
 >value : { isSuccess: true; } | { isSuccess: false; }
@@ -70,15 +70,15 @@ function f2<T>(a: Item[]) {
 >a.map(item => ({ ...item })).filter(value => {}) : ({ isSuccess: true; } | { isSuccess: false; })[]
 >                                                 : ^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^
 >a.map(item => ({ ...item })).filter : { <S extends { isSuccess: true; } | { isSuccess: false; }>(predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => value is S, thisArg?: any): S[]; (predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => unknown, thisArg?: any): ({ isSuccess: true; } | { isSuccess: false; })[]; }
->                                    : ^^^ ^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^  ^^^
+>                                    : ^^^ ^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^
 >a.map(item => ({ ...item })) : ({ isSuccess: true; } | { isSuccess: false; })[]
 >                             : ^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^
 >a.map : <U>(callbackfn: (value: Item, index: number, array: Item[]) => U, thisArg?: any) => U[]
->      : ^ ^^          ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>      : ^ ^^          ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >a : Item[]
 >  : ^^^^^^
 >map : <U>(callbackfn: (value: Item, index: number, array: Item[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >item => ({ ...item }) : (item: Item) => { isSuccess: true; } | { isSuccess: false; }
 >                      : ^    ^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^
 >item : Item
@@ -90,7 +90,7 @@ function f2<T>(a: Item[]) {
 >item : Item
 >     : ^^^^
 >filter : { <S extends { isSuccess: true; } | { isSuccess: false; }>(predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => value is S, thisArg?: any): S[]; (predicate: (value: { isSuccess: true; } | { isSuccess: false; }, index: number, array: ({ isSuccess: true; } | { isSuccess: false; })[]) => unknown, thisArg?: any): ({ isSuccess: true; } | { isSuccess: false; })[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^
 >value => {} : (value: { isSuccess: true; } | { isSuccess: false; }) => void
 >            : ^     ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^
 >value : { isSuccess: true; } | { isSuccess: false; }
diff --git a/tests/baselines/reference/objectRestBindingContextualInference.types b/tests/baselines/reference/objectRestBindingContextualInference.types
index f6fced90ceeed..2906e383c815b 100644
--- a/tests/baselines/reference/objectRestBindingContextualInference.types
+++ b/tests/baselines/reference/objectRestBindingContextualInference.types
@@ -59,7 +59,7 @@ declare const test: TestInterface;
 
 const { prepare, ...rest } = setupImages(test, ["image"]);
 >prepare : () => { type: "image"; }
->        : ^^^^^^        ^^^^^^^   
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^
 >rest : { image: File; }
 >     : ^^^^^^^^^^^^^^^^
 >setupImages(test, ["image"]) : SetupImages<"image">
diff --git a/tests/baselines/reference/objectRestForOf.types b/tests/baselines/reference/objectRestForOf.types
index 84126aee454fd..cceefcfec5407 100644
--- a/tests/baselines/reference/objectRestForOf.types
+++ b/tests/baselines/reference/objectRestForOf.types
@@ -61,11 +61,11 @@ for (const norest of array.map(a => ({ ...a, x: 'a string' }))) {
 >array.map(a => ({ ...a, x: 'a string' })) : { x: string; y: string; }[]
 >                                          : ^^^^^^^^^^^^^^^^      ^^^^^
 >array.map : <U>(callbackfn: (value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg?: any) => U[]
->          : ^ ^^          ^^^     ^^^^^^^      ^^^^^      ^^^^^     ^^      ^^     ^^^^^^^      ^^^^^      ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>          : ^ ^^          ^^^     ^^^^^^^      ^^^^^      ^^^^^     ^^      ^^     ^^^^^^^      ^^^^^      ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >array : { x: number; y: string; }[]
 >      : ^^^^^      ^^^^^      ^^^^^
 >map : <U>(callbackfn: (value: { x: number; y: string; }, index: number, array: { x: number; y: string; }[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^      ^^^^^      ^^^^^     ^^      ^^     ^^^^^^^      ^^^^^      ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^      ^^^^^      ^^^^^     ^^      ^^     ^^^^^^^      ^^^^^      ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >a => ({ ...a, x: 'a string' }) : (a: { x: number; y: string; }) => { x: string; y: string; }
 >                               : ^ ^^^^^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^
 >a : { x: number; y: string; }
diff --git a/tests/baselines/reference/overEagerReturnTypeSpecialization.types b/tests/baselines/reference/overEagerReturnTypeSpecialization.types
index f3bbf83cc701e..40d8343e5ec2f 100644
--- a/tests/baselines/reference/overEagerReturnTypeSpecialization.types
+++ b/tests/baselines/reference/overEagerReturnTypeSpecialization.types
@@ -23,15 +23,15 @@ var r1: I1<string> = v1.func(num => num.toString()) // Correctly returns an I1<s
 >v1.func(num => num.toString()) // Correctly returns an I1<string>           .func(str => str.length) : I1<number>
 >                                                                                                     : ^^^^^^^^^^
 >v1.func(num => num.toString()) // Correctly returns an I1<string>           .func : <U>(callback: (value: string) => U) => I1<U>
->                                                                                  : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^ 
+>                                                                                  : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^
 >v1.func(num => num.toString()) : I1<string>
 >                               : ^^^^^^^^^^
 >v1.func : <U>(callback: (value: number) => U) => I1<U>
->        : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^ 
+>        : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^
 >v1 : I1<number>
 >   : ^^^^^^^^^^
 >func : <U>(callback: (value: number) => U) => I1<U>
->     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^ 
+>     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^
 >num => num.toString() : (num: number) => string
 >                      : ^   ^^^^^^^^^^^^^^^^^^^
 >num : number
@@ -47,7 +47,7 @@ var r1: I1<string> = v1.func(num => num.toString()) // Correctly returns an I1<s
 
            .func(str => str.length);    // should error
 >func : <U>(callback: (value: string) => U) => I1<U>
->     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^ 
+>     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^
 >str => str.length : (str: string) => number
 >                  : ^   ^^^^^^^^^^^^^^^^^^^
 >str : string
@@ -65,15 +65,15 @@ var r2: I1<number> = v1.func(num => num.toString()) // Correctly returns an I1<s
 >v1.func(num => num.toString()) // Correctly returns an I1<string>           .func(str => str.length) : I1<number>
 >                                                                                                     : ^^^^^^^^^^
 >v1.func(num => num.toString()) // Correctly returns an I1<string>           .func : <U>(callback: (value: string) => U) => I1<U>
->                                                                                  : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^ 
+>                                                                                  : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^
 >v1.func(num => num.toString()) : I1<string>
 >                               : ^^^^^^^^^^
 >v1.func : <U>(callback: (value: number) => U) => I1<U>
->        : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^ 
+>        : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^
 >v1 : I1<number>
 >   : ^^^^^^^^^^
 >func : <U>(callback: (value: number) => U) => I1<U>
->     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^ 
+>     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^
 >num => num.toString() : (num: number) => string
 >                      : ^   ^^^^^^^^^^^^^^^^^^^
 >num : number
@@ -89,7 +89,7 @@ var r2: I1<number> = v1.func(num => num.toString()) // Correctly returns an I1<s
 
            .func(str => str.length);    // should be ok 
 >func : <U>(callback: (value: string) => U) => I1<U>
->     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^   ^ 
+>     : ^ ^^        ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^
 >str => str.length : (str: string) => number
 >                  : ^   ^^^^^^^^^^^^^^^^^^^
 >str : string
diff --git a/tests/baselines/reference/parenthesizedJSDocCastAtReturnStatement.types b/tests/baselines/reference/parenthesizedJSDocCastAtReturnStatement.types
index c4836b5981740..25270ffaee519 100644
--- a/tests/baselines/reference/parenthesizedJSDocCastAtReturnStatement.types
+++ b/tests/baselines/reference/parenthesizedJSDocCastAtReturnStatement.types
@@ -31,12 +31,12 @@ const getStringGetter = (key) => {
 >                 : ^^^^^^
 >cache.get(key) : string | Set<string> | undefined
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->cache.get : (key: string) => (string | Set<string>) | undefined
->          : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            
+>cache.get : (key: string) => string | Set<string> | undefined
+>          : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >cache : Map<string, string | Set<string>>
 >      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->get : (key: string) => (string | Set<string>) | undefined
->    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            
+>get : (key: string) => string | Set<string> | undefined
+>    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >key : string
 >    : ^^^^^^
   }
diff --git a/tests/baselines/reference/parserRealSource14.types b/tests/baselines/reference/parserRealSource14.types
index afc1b09066d54..6619d911f4142 100644
--- a/tests/baselines/reference/parserRealSource14.types
+++ b/tests/baselines/reference/parserRealSource14.types
@@ -196,7 +196,7 @@ module TypeScript {
 >this.asts.map((value) => { return value; }) : TypeScript.AST[]
 >                                            : ^^^^^^^^^^^^^^^^
 >this.asts.map : <U>(callbackfn: (value: TypeScript.AST, index: number, array: TypeScript.AST[]) => U, thisArg?: any) => U[]
->              : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>              : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >this.asts : TypeScript.AST[]
 >          : ^^^^^^^^^^^^^^^^
 >this : this
@@ -204,7 +204,7 @@ module TypeScript {
 >asts : TypeScript.AST[]
 >     : ^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: TypeScript.AST, index: number, array: TypeScript.AST[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(value) => { return value; } : (value: TypeScript.AST) => TypeScript.AST
 >                             : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value : TypeScript.AST
@@ -286,16 +286,16 @@ module TypeScript {
                 this.asts.pop();
 >this.asts.pop() : TypeScript.AST
 >                : ^^^^^^^^^^^^^^
->this.asts.pop : () => TypeScript.AST | undefined
->              : ^^^^^^^^^^^^^^^^^^^^            
+>this.asts.pop : () => TypeScript.AST
+>              : ^^^^^^^^^^^^^^^^^^^^
 >this.asts : TypeScript.AST[]
 >          : ^^^^^^^^^^^^^^^^
 >this : this
 >     : ^^^^
 >asts : TypeScript.AST[]
 >     : ^^^^^^^^^^^^^^^^
->pop : () => TypeScript.AST | undefined
->    : ^^^^^^^^^^^^^^^^^^^^            
+>pop : () => TypeScript.AST
+>    : ^^^^^^^^^^^^^^^^^^^^
             }
             return head;
 >head : TypeScript.AST
@@ -335,16 +335,16 @@ module TypeScript {
                 this.asts.pop();
 >this.asts.pop() : TypeScript.AST
 >                : ^^^^^^^^^^^^^^
->this.asts.pop : () => TypeScript.AST | undefined
->              : ^^^^^^^^^^^^^^^^^^^^            
+>this.asts.pop : () => TypeScript.AST
+>              : ^^^^^^^^^^^^^^^^^^^^
 >this.asts : TypeScript.AST[]
 >          : ^^^^^^^^^^^^^^^^
 >this : this
 >     : ^^^^
 >asts : TypeScript.AST[]
 >     : ^^^^^^^^^^^^^^^^
->pop : () => TypeScript.AST | undefined
->    : ^^^^^^^^^^^^^^^^^^^^            
+>pop : () => TypeScript.AST
+>    : ^^^^^^^^^^^^^^^^^^^^
             }
             this.top = this.asts.length;
 >this.top = this.asts.length : number
diff --git a/tests/baselines/reference/parserRealSource4.types b/tests/baselines/reference/parserRealSource4.types
index b17459e9e063b..639d1e2f0595e 100644
--- a/tests/baselines/reference/parserRealSource4.types
+++ b/tests/baselines/reference/parserRealSource4.types
@@ -666,7 +666,7 @@ module TypeScript {
 >this.primaryTable.getAllKeys().concat(this.secondaryTable.getAllKeys()) : string[]
 >                                                                        : ^^^^^^^^
 >this.primaryTable.getAllKeys().concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
->                                      : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>                                      : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.primaryTable.getAllKeys() : string[]
 >                               : ^^^^^^^^
 >this.primaryTable.getAllKeys : () => string[]
@@ -680,7 +680,7 @@ module TypeScript {
 >getAllKeys : () => string[]
 >           : ^^^^^^        
 >concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.secondaryTable.getAllKeys() : string[]
 >                                 : ^^^^^^^^
 >this.secondaryTable.getAllKeys : () => string[]
diff --git a/tests/baselines/reference/parserRealSource8.types b/tests/baselines/reference/parserRealSource8.types
index fe9c659ffc140..011cf47ae9f94 100644
--- a/tests/baselines/reference/parserRealSource8.types
+++ b/tests/baselines/reference/parserRealSource8.types
@@ -3761,16 +3761,16 @@ module TypeScript {
                 context.modDeclChain.pop();
 >context.modDeclChain.pop() : ModuleDeclaration
 >                           : ^^^^^^^^^^^^^^^^^
->context.modDeclChain.pop : () => ModuleDeclaration | undefined
->                         : ^^^^^^^^^^^^^^^^^^^^^^^            
+>context.modDeclChain.pop : () => ModuleDeclaration
+>                         : ^^^^^^^^^^^^^^^^^^^^^^^
 >context.modDeclChain : ModuleDeclaration[]
 >                     : ^^^^^^^^^^^^^^^^^^^
 >context : AssignScopeContext
 >        : ^^^^^^^^^^^^^^^^^^
 >modDeclChain : ModuleDeclaration[]
 >             : ^^^^^^^^^^^^^^^^^^^
->pop : () => ModuleDeclaration | undefined
->    : ^^^^^^^^^^^^^^^^^^^^^^^            
+>pop : () => ModuleDeclaration
+>    : ^^^^^^^^^^^^^^^^^^^^^^^
 
                 if (context.modDeclChain.length >= 1) {
 >context.modDeclChain.length >= 1 : boolean
diff --git a/tests/baselines/reference/parserharness.types b/tests/baselines/reference/parserharness.types
index 327d04974d861..0326d8453ba19 100644
--- a/tests/baselines/reference/parserharness.types
+++ b/tests/baselines/reference/parserharness.types
@@ -109,11 +109,11 @@ function filePath(fullPath: string) {
 >components.slice(0, components.length - 1) : string[]
 >                                           : ^^^^^^^^
 >components.slice : (start?: number, end?: number) => string[]
->                 : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>                 : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >components : string[]
 >           : ^^^^^^^^
 >slice : (start?: number, end?: number) => string[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 >components.length - 1 : number
@@ -2283,16 +2283,16 @@ module Harness {
                     Runnable.currentStack.pop();
 >Runnable.currentStack.pop() : Runnable
 >                            : ^^^^^^^^
->Runnable.currentStack.pop : () => Runnable | undefined
->                          : ^^^^^^^^^^^^^^            
+>Runnable.currentStack.pop : () => Runnable
+>                          : ^^^^^^^^^^^^^^
 >Runnable.currentStack : Runnable[]
 >                      : ^^^^^^^^^^
 >Runnable : typeof Runnable
 >         : ^^^^^^^^^^^^^^^
 >currentStack : Runnable[]
 >             : ^^^^^^^^^^
->pop : () => Runnable | undefined
->    : ^^^^^^^^^^^^^^            
+>pop : () => Runnable
+>    : ^^^^^^^^^^^^^^
 
                     done()
 >done() : void
@@ -2429,16 +2429,16 @@ module Harness {
                 Runnable.currentStack.pop();
 >Runnable.currentStack.pop() : Runnable
 >                            : ^^^^^^^^
->Runnable.currentStack.pop : () => Runnable | undefined
->                          : ^^^^^^^^^^^^^^            
+>Runnable.currentStack.pop : () => Runnable
+>                          : ^^^^^^^^^^^^^^
 >Runnable.currentStack : Runnable[]
 >                      : ^^^^^^^^^^
 >Runnable : typeof Runnable
 >         : ^^^^^^^^^^^^^^^
 >currentStack : Runnable[]
 >             : ^^^^^^^^^^
->pop : () => Runnable | undefined
->    : ^^^^^^^^^^^^^^            
+>pop : () => Runnable
+>    : ^^^^^^^^^^^^^^
 
                 if (e) {
 >e : any
@@ -7920,11 +7920,11 @@ module Harness {
 >lines.concat(v.file.lines) : any[]
 >                           : ^^^^^
 >lines.concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
->             : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^  ^^^
+>             : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^
 >lines : any[]
 >      : ^^^^^
 >concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^
 >v.file.lines : string[]
 >             : ^^^^^^^^
 >v.file : WriterAggregator
@@ -9098,11 +9098,11 @@ module Harness {
 >units.slice(0, units.length - 1) : TestCaseParser.TestUnitData[]
 >                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >units.slice : (start?: number, end?: number) => TestCaseParser.TestUnitData[]
->            : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  
+>            : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >units : TestCaseParser.TestUnitData[]
 >      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >slice : (start?: number, end?: number) => TestCaseParser.TestUnitData[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 >units.length - 1 : number
@@ -10578,7 +10578,7 @@ module Harness {
 >this.editRanges.splice(0, this.maxScriptVersions - this.editRanges.length) : { length: number; editRange: TypeScript.ScriptEditRange; }[]
 >                                                                           : ^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^
 >this.editRanges.splice : { (start: number, deleteCount?: number): { length: number; editRange: TypeScript.ScriptEditRange; }[]; (start: number, deleteCount: number, ...items: { length: number; editRange: TypeScript.ScriptEditRange; }[]): { length: number; editRange: TypeScript.ScriptEditRange; }[]; }
->                       : ^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^  ^^^
+>                       : ^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^
 >this.editRanges : { length: number; editRange: TypeScript.ScriptEditRange; }[]
 >                : ^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^
 >this : this
@@ -10586,7 +10586,7 @@ module Harness {
 >editRanges : { length: number; editRange: TypeScript.ScriptEditRange; }[]
 >           : ^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^
 >splice : { (start: number, deleteCount?: number): { length: number; editRange: TypeScript.ScriptEditRange; }[]; (start: number, deleteCount: number, ...items: { length: number; editRange: TypeScript.ScriptEditRange; }[]): { length: number; editRange: TypeScript.ScriptEditRange; }[]; }
->       : ^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^  ^^^
+>       : ^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^
 >0 : 0
 >  : ^
 >this.maxScriptVersions - this.editRanges.length : number
@@ -10719,7 +10719,7 @@ module Harness {
 >this.editRanges.slice(initialEditRangeIndex) : { length: number; editRange: TypeScript.ScriptEditRange; }[]
 >                                             : ^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^
 >this.editRanges.slice : (start?: number, end?: number) => { length: number; editRange: TypeScript.ScriptEditRange; }[]
->                      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^  
+>                      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^
 >this.editRanges : { length: number; editRange: TypeScript.ScriptEditRange; }[]
 >                : ^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^
 >this : this
@@ -10727,7 +10727,7 @@ module Harness {
 >editRanges : { length: number; editRange: TypeScript.ScriptEditRange; }[]
 >           : ^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^
 >slice : (start?: number, end?: number) => { length: number; editRange: TypeScript.ScriptEditRange; }[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^
 >initialEditRangeIndex : number
 >                      : ^^^^^^
 
@@ -10741,11 +10741,11 @@ module Harness {
 >entries.map(x => x.editRange.minChar) : any[]
 >                                      : ^^^^^
 >entries.map : <U>(callbackfn: (value: { length: number; editRange: TypeScript.ScriptEditRange; }, index: number, array: { length: number; editRange: TypeScript.ScriptEditRange; }[]) => U, thisArg?: any) => U[]
->            : ^ ^^          ^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^     ^^      ^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>            : ^ ^^          ^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^     ^^      ^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >entries : { length: number; editRange: TypeScript.ScriptEditRange; }[]
 >        : ^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^
 >map : <U>(callbackfn: (value: { length: number; editRange: TypeScript.ScriptEditRange; }, index: number, array: { length: number; editRange: TypeScript.ScriptEditRange; }[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^     ^^      ^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^     ^^      ^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >x => x.editRange.minChar : (x: { length: number; editRange: TypeScript.ScriptEditRange; }) => any
 >                         : ^ ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^
 >x : { length: number; editRange: TypeScript.ScriptEditRange; }
@@ -10791,11 +10791,11 @@ module Harness {
 >entries.map(x => x.length - x.editRange.limChar) : number[]
 >                                                 : ^^^^^^^^
 >entries.map : <U>(callbackfn: (value: { length: number; editRange: TypeScript.ScriptEditRange; }, index: number, array: { length: number; editRange: TypeScript.ScriptEditRange; }[]) => U, thisArg?: any) => U[]
->            : ^ ^^          ^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^     ^^      ^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>            : ^ ^^          ^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^     ^^      ^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >entries : { length: number; editRange: TypeScript.ScriptEditRange; }[]
 >        : ^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^
 >map : <U>(callbackfn: (value: { length: number; editRange: TypeScript.ScriptEditRange; }, index: number, array: { length: number; editRange: TypeScript.ScriptEditRange; }[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^     ^^      ^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^     ^^      ^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >x => x.length - x.editRange.limChar : (x: { length: number; editRange: TypeScript.ScriptEditRange; }) => number
 >                                    : ^ ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^^
 >x : { length: number; editRange: TypeScript.ScriptEditRange; }
@@ -10849,11 +10849,11 @@ module Harness {
 >entries.map(x => x.editRange.delta) : any[]
 >                                    : ^^^^^
 >entries.map : <U>(callbackfn: (value: { length: number; editRange: TypeScript.ScriptEditRange; }, index: number, array: { length: number; editRange: TypeScript.ScriptEditRange; }[]) => U, thisArg?: any) => U[]
->            : ^ ^^          ^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^     ^^      ^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>            : ^ ^^          ^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^     ^^      ^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >entries : { length: number; editRange: TypeScript.ScriptEditRange; }[]
 >        : ^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^
 >map : <U>(callbackfn: (value: { length: number; editRange: TypeScript.ScriptEditRange; }, index: number, array: { length: number; editRange: TypeScript.ScriptEditRange; }[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^     ^^      ^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^     ^^      ^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >x => x.editRange.delta : (x: { length: number; editRange: TypeScript.ScriptEditRange; }) => any
 >                       : ^ ^^^^^^^^^^^^      ^^^^^^^^^^^^^                          ^^^^^^^^^^^
 >x : { length: number; editRange: TypeScript.ScriptEditRange; }
diff --git a/tests/baselines/reference/partiallyNamedTuples2.types b/tests/baselines/reference/partiallyNamedTuples2.types
index 6c1700869d205..d2abb8d3dcb9d 100644
--- a/tests/baselines/reference/partiallyNamedTuples2.types
+++ b/tests/baselines/reference/partiallyNamedTuples2.types
@@ -50,11 +50,11 @@ const matches = x.get(id1);
 >x.get(id1) : Iterable<[id2: string, object]>
 >           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x.get : <Key extends [id1: string, id2: string] | [id1: string] | []>(...key: Key) => GetResult<[id1: string, id2: string], Key, object>
->      : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^          ^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^  ^^^^^^ 
+>      : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : MultiKeyMap<[id1: string, id2: string], object>
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >get : <Key extends [id1: string, id2: string] | [id1: string] | []>(...key: Key) => GetResult<[id1: string, id2: string], Key, object>
->    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^          ^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^  ^^^^^^ 
+>    : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >id1 : string
 >    : ^^^^^^
 
diff --git a/tests/baselines/reference/privateNameMethodAsync.types b/tests/baselines/reference/privateNameMethodAsync.types
index d2f113ff10e89..5f7f74f19b003 100644
--- a/tests/baselines/reference/privateNameMethodAsync.types
+++ b/tests/baselines/reference/privateNameMethodAsync.types
@@ -55,7 +55,7 @@ const C = class {
 >this.#baz().next() : IteratorResult<number, void>
 >                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.#baz().next : (...args: [] | [unknown]) => IteratorResult<number, void>
->                 : ^^^^    ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^  ^^^^ 
+>                 : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.#baz() : Generator<number, void, unknown>
 >            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.#baz : () => Generator<number, void, unknown>
@@ -63,7 +63,7 @@ const C = class {
 >this : this
 >     : ^^^^
 >next : (...args: [] | [unknown]) => IteratorResult<number, void>
->     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^  ^^^^ 
+>     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value : number | void
 >      : ^^^^^^^^^^^^^
 >0 : 0
@@ -81,7 +81,7 @@ const C = class {
 >this.#qux().next() : Promise<IteratorResult<number, void>>
 >                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.#qux().next : (...args: [] | [unknown]) => Promise<IteratorResult<number, void>>
->                 : ^^^^    ^^^^^^^^^^^^^^^^^^^^^                       ^^^^^^  ^^^^  
+>                 : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.#qux() : AsyncGenerator<number, void, unknown>
 >            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.#qux : () => AsyncGenerator<number, void, unknown>
@@ -89,7 +89,7 @@ const C = class {
 >this : this
 >     : ^^^^
 >next : (...args: [] | [unknown]) => Promise<IteratorResult<number, void>>
->     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^                       ^^^^^^  ^^^^  
+>     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value : number | void
 >      : ^^^^^^^^^^^^^
 >0 : 0
@@ -129,7 +129,7 @@ new C().foo().then(console.log);
 >new C().foo().then(console.log) : Promise<void>
 >                                : ^^^^^^^^^^^^^
 >new C().foo().then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                   : ^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                   : ^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >new C().foo() : Promise<number>
 >              : ^^^^^^^^^^^^^^^
 >new C().foo : () => Promise<number>
@@ -141,7 +141,7 @@ new C().foo().then(console.log);
 >foo : () => Promise<number>
 >    : ^^^^^^^^^^^^^^^^^^^^^
 >then : <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >console.log : (...data: any[]) => void
 >            : ^^^^    ^^     ^^^^^    
 >console : Console
diff --git a/tests/baselines/reference/privateNameStaticMethodAsync.types b/tests/baselines/reference/privateNameStaticMethodAsync.types
index 1a1205a51ddd7..ddb582f217407 100644
--- a/tests/baselines/reference/privateNameStaticMethodAsync.types
+++ b/tests/baselines/reference/privateNameStaticMethodAsync.types
@@ -55,7 +55,7 @@ const C = class {
 >this.#baz().next() : IteratorResult<number, void>
 >                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.#baz().next : (...args: [] | [unknown]) => IteratorResult<number, void>
->                 : ^^^^    ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^  ^^^^ 
+>                 : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.#baz() : Generator<number, void, unknown>
 >            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.#baz : () => Generator<number, void, unknown>
@@ -63,7 +63,7 @@ const C = class {
 >this : typeof C
 >     : ^^^^^^^^
 >next : (...args: [] | [unknown]) => IteratorResult<number, void>
->     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^  ^^^^ 
+>     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value : number | void
 >      : ^^^^^^^^^^^^^
 >0 : 0
@@ -81,7 +81,7 @@ const C = class {
 >this.#qux().next() : Promise<IteratorResult<number, void>>
 >                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.#qux().next : (...args: [] | [unknown]) => Promise<IteratorResult<number, void>>
->                 : ^^^^    ^^^^^^^^^^^^^^^^^^^^^                       ^^^^^^  ^^^^  
+>                 : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.#qux() : AsyncGenerator<number, void, unknown>
 >            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.#qux : () => AsyncGenerator<number, void, unknown>
@@ -89,7 +89,7 @@ const C = class {
 >this : typeof C
 >     : ^^^^^^^^
 >next : (...args: [] | [unknown]) => Promise<IteratorResult<number, void>>
->     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^                       ^^^^^^  ^^^^  
+>     : ^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value : number | void
 >      : ^^^^^^^^^^^^^
 >0 : 0
diff --git a/tests/baselines/reference/promiseChaining.types b/tests/baselines/reference/promiseChaining.types
index 40844e089e491..3f7c0148c4ed2 100644
--- a/tests/baselines/reference/promiseChaining.types
+++ b/tests/baselines/reference/promiseChaining.types
@@ -38,11 +38,11 @@ class Chain<T> {
 >this.then(x => result)/*S*/.then(x => "abc")/*string*/.then(x => x.length) : Chain<number>
 >                                                                           : ^^^^^^^^^^^^^
 >this.then(x => result)/*S*/.then(x => "abc")/*string*/.then : <S>(cb: (x: string) => S) => Chain<S>
->                                                            : ^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^      ^ 
+>                                                            : ^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.then(x => result)/*S*/.then(x => "abc") : Chain<string>
 >                                             : ^^^^^^^^^^^^^
 >this.then(x => result)/*S*/.then : <S>(cb: (x: S_1) => S) => Chain<S>
->                                 : ^ ^^  ^^^ ^^^^^^^^^^^^^^^^      ^ 
+>                                 : ^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >this.then(x => result) : Chain<S>
 >                       : ^^^^^^^^
 >this.then : <S>(cb: (x: T) => S) => Chain<S>
@@ -58,7 +58,7 @@ class Chain<T> {
 >result : S
 >       : ^
 >then : <S>(cb: (x: S_1) => S) => Chain<S>
->     : ^ ^^  ^^^ ^^^^^^^^^^^^^^^^      ^ 
+>     : ^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
 >x => "abc" : (x: S) => string
 >           : ^ ^^^^^^^^^^^^^^
 >x : S
@@ -66,7 +66,7 @@ class Chain<T> {
 >"abc" : "abc"
 >      : ^^^^^
 >then : <S>(cb: (x: string) => S) => Chain<S>
->     : ^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^      ^ 
+>     : ^ ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x.length : (x: string) => number
 >              : ^ ^^^^^^^^^^^^^^^^^^^
 >x : string
diff --git a/tests/baselines/reference/promiseChaining1.types b/tests/baselines/reference/promiseChaining1.types
index d45bfae070dc1..3882026930f9a 100644
--- a/tests/baselines/reference/promiseChaining1.types
+++ b/tests/baselines/reference/promiseChaining1.types
@@ -41,11 +41,11 @@ class Chain2<T extends { length: number }> {
 >this.then(x => result)/*S*/.then(x => "abc")/*Function*/.then(x => x.length) : Chain2<Function>
 >                                                                             : ^^^^^^^^^^^^^^^^
 >this.then(x => result)/*S*/.then(x => "abc")/*Function*/.then : <S extends Function>(cb: (x: Function) => S) => Chain2<S>
->                                                              : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^       ^ 
+>                                                              : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.then(x => result)/*S*/.then(x => "abc") : Chain2<Function>
 >                                             : ^^^^^^^^^^^^^^^^
 >this.then(x => result)/*S*/.then : <S extends Function>(cb: (x: S_1) => S) => Chain2<S>
->                                 : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^       ^ 
+>                                 : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.then(x => result) : Chain2<S>
 >                       : ^^^^^^^^^
 >this.then : <S extends Function>(cb: (x: T) => S) => Chain2<S>
@@ -61,7 +61,7 @@ class Chain2<T extends { length: number }> {
 >result : S
 >       : ^
 >then : <S extends Function>(cb: (x: S_1) => S) => Chain2<S>
->     : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^       ^ 
+>     : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => "abc" : (x: S) => string
 >           : ^ ^^^^^^^^^^^^^^
 >x : S
@@ -69,7 +69,7 @@ class Chain2<T extends { length: number }> {
 >"abc" : "abc"
 >      : ^^^^^
 >then : <S extends Function>(cb: (x: Function) => S) => Chain2<S>
->     : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^       ^ 
+>     : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x.length : (x: Function) => number
 >              : ^ ^^^^^^^^^^^^^^^^^^^^^
 >x : Function
diff --git a/tests/baselines/reference/promiseChaining2.types b/tests/baselines/reference/promiseChaining2.types
index 6faacac3a205e..3dcb72f2436f3 100644
--- a/tests/baselines/reference/promiseChaining2.types
+++ b/tests/baselines/reference/promiseChaining2.types
@@ -41,11 +41,11 @@ class Chain2<T extends { length: number }> {
 >this.then(x => result).then(x => "abc").then(x => x.length) : Chain2<Function>
 >                                                            : ^^^^^^^^^^^^^^^^
 >this.then(x => result).then(x => "abc").then : <S extends Function>(cb: (x: Function) => S) => Chain2<S>
->                                             : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^       ^ 
+>                                             : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.then(x => result).then(x => "abc") : Chain2<Function>
 >                                        : ^^^^^^^^^^^^^^^^
 >this.then(x => result).then : <S extends Function>(cb: (x: S_1) => S) => Chain2<S>
->                            : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^       ^ 
+>                            : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >this.then(x => result) : Chain2<S>
 >                       : ^^^^^^^^^
 >this.then : <S extends Function>(cb: (x: T) => S) => Chain2<S>
@@ -61,7 +61,7 @@ class Chain2<T extends { length: number }> {
 >result : S
 >       : ^
 >then : <S extends Function>(cb: (x: S_1) => S) => Chain2<S>
->     : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^       ^ 
+>     : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => "abc" : (x: S) => string
 >           : ^ ^^^^^^^^^^^^^^
 >x : S
@@ -69,7 +69,7 @@ class Chain2<T extends { length: number }> {
 >"abc" : "abc"
 >      : ^^^^^
 >then : <S extends Function>(cb: (x: Function) => S) => Chain2<S>
->     : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^       ^ 
+>     : ^ ^^^^^^^^^        ^^  ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x.length : (x: Function) => number
 >              : ^ ^^^^^^^^^^^^^^^^^^^^^
 >x : Function
diff --git a/tests/baselines/reference/promisePermutations.types b/tests/baselines/reference/promisePermutations.types
index 1f9e3537b3c56..7901f8bb80b4c 100644
--- a/tests/baselines/reference/promisePermutations.types
+++ b/tests/baselines/reference/promisePermutations.types
@@ -391,11 +391,11 @@ var r1a = r1.then(testFunction, testFunction, testFunction);
 >r1.then(testFunction, testFunction, testFunction) : IPromise<number>
 >                                                  : ^^^^^^^^^^^^^^^^
 >r1.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r1 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -409,15 +409,15 @@ var r1b = r1.then(testFunction, testFunction, testFunction).then(testFunction, t
 >r1.then(testFunction, testFunction, testFunction).then(testFunction, testFunction, testFunction) : IPromise<number>
 >                                                                                                 : ^^^^^^^^^^^^^^^^
 >r1.then(testFunction, testFunction, testFunction).then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                                       : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                                       : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r1.then(testFunction, testFunction, testFunction) : IPromise<number>
 >                                                  : ^^^^^^^^^^^^^^^^
 >r1.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r1 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -425,7 +425,7 @@ var r1b = r1.then(testFunction, testFunction, testFunction).then(testFunction, t
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -439,11 +439,11 @@ var r1c = r1.then(testFunctionP, testFunctionP, testFunctionP);
 >r1.then(testFunctionP, testFunctionP, testFunctionP) : IPromise<number>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r1.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r1 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >testFunctionP : () => Promise<number>
@@ -461,11 +461,11 @@ var s1a = s1.then(testFunction, testFunction, testFunction);
 >s1.then(testFunction, testFunction, testFunction) : Promise<IPromise<number>>
 >                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -479,11 +479,11 @@ var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP);
 >s1.then(testFunctionP, testFunctionP, testFunctionP) : Promise<number>
 >                                                     : ^^^^^^^^^^^^^^^
 >s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >testFunctionP : () => Promise<number>
@@ -497,11 +497,11 @@ var s1c = s1.then(testFunctionP, testFunction, testFunction);
 >s1.then(testFunctionP, testFunction, testFunction) : Promise<IPromise<number>>
 >                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >testFunction : () => IPromise<number>
@@ -515,15 +515,15 @@ var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction,
 >s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction) : Promise<IPromise<number>>
 >                                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s1.then(testFunctionP, testFunction, testFunction).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                        : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                        : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1.then(testFunctionP, testFunction, testFunction) : Promise<IPromise<number>>
 >                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >testFunction : () => IPromise<number>
@@ -531,7 +531,7 @@ var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction,
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -551,11 +551,11 @@ var r2a = r2.then(testFunction2, testFunction2, testFunction2);
 >r2.then(testFunction2, testFunction2, testFunction2) : IPromise<{ x: number; }>
 >                                                     : ^^^^^^^^^^^^^^      ^^^^
 >r2.then : { <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r2 : IPromise<{ x: number; }>
 >   : ^^^^^^^^^^^^^^      ^^^^
 >then : { <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -569,15 +569,15 @@ var r2b = r2.then(testFunction2, testFunction2, testFunction2).then(testFunction
 >r2.then(testFunction2, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : IPromise<{ x: number; }>
 >                                                                                                       : ^^^^^^^^^^^^^^      ^^^^
 >r2.then(testFunction2, testFunction2, testFunction2).then : { <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                                          : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                                          : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r2.then(testFunction2, testFunction2, testFunction2) : IPromise<{ x: number; }>
 >                                                     : ^^^^^^^^^^^^^^      ^^^^
 >r2.then : { <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r2 : IPromise<{ x: number; }>
 >   : ^^^^^^^^^^^^^^      ^^^^
 >then : { <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -585,7 +585,7 @@ var r2b = r2.then(testFunction2, testFunction2, testFunction2).then(testFunction
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >then : { <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -605,11 +605,11 @@ var s2a = s2.then(testFunction2, testFunction2, testFunction2);
 >s2.then(testFunction2, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2 : Promise<{ x: number; }>
 >   : ^^^^^^^^^^^^^      ^^^^
 >then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -623,11 +623,11 @@ var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P);
 >s2.then(testFunction2P, testFunction2P, testFunction2P) : Promise<{ x: number; }>
 >                                                        : ^^^^^^^^^^^^^      ^^^^
 >s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2 : Promise<{ x: number; }>
 >   : ^^^^^^^^^^^^^      ^^^^
 >then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2P : () => Promise<{ x: number; }>
 >               : ^^^^^^                       
 >testFunction2P : () => Promise<{ x: number; }>
@@ -641,11 +641,11 @@ var s2c = s2.then(testFunction2P, testFunction2, testFunction2);
 >s2.then(testFunction2P, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2 : Promise<{ x: number; }>
 >   : ^^^^^^^^^^^^^      ^^^^
 >then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2P : () => Promise<{ x: number; }>
 >               : ^^^^^^                       
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -659,15 +659,15 @@ var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunctio
 >s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
 >                                                                                                        : ^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >s2.then(testFunction2P, testFunction2, testFunction2).then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                           : ^^^        ^^^^^^^^^^^^^^^^^      ^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                           : ^^^        ^^^^^^^^^^^^^^^^^      ^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2.then(testFunction2P, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2 : Promise<{ x: number; }>
 >   : ^^^^^^^^^^^^^      ^^^^
 >then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2P : () => Promise<{ x: number; }>
 >               : ^^^^^^                       
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -675,7 +675,7 @@ var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunctio
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^      ^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^      ^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -693,11 +693,11 @@ var r3a = r3.then(testFunction3, testFunction3, testFunction3);
 >r3.then(testFunction3, testFunction3, testFunction3) : IPromise<number>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r3.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r3 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -711,15 +711,15 @@ var r3b = r3.then(testFunction3, testFunction3, testFunction3).then(testFunction
 >r3.then(testFunction3, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : IPromise<number>
 >                                                                                                       : ^^^^^^^^^^^^^^^^
 >r3.then(testFunction3, testFunction3, testFunction3).then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                                          : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                                          : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r3.then(testFunction3, testFunction3, testFunction3) : IPromise<number>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r3.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r3 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -727,7 +727,7 @@ var r3b = r3.then(testFunction3, testFunction3, testFunction3).then(testFunction
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -745,11 +745,11 @@ var s3a = s3.then(testFunction3, testFunction3, testFunction3);
 >s3.then(testFunction3, testFunction3, testFunction3) : Promise<IPromise<number>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -763,11 +763,11 @@ var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
 >s3.then(testFunction3P, testFunction3P, testFunction3P) : Promise<number>
 >                                                        : ^^^^^^^^^^^^^^^
 >s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3P : (x: number) => Promise<number>
 >               : ^ ^^      ^^^^^               
 >testFunction3P : (x: number) => Promise<number>
@@ -781,11 +781,11 @@ var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
 >s3.then(testFunction3P, testFunction3, testFunction3) : Promise<IPromise<number>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3P : (x: number) => Promise<number>
 >               : ^ ^^      ^^^^^               
 >testFunction3 : (x: number) => IPromise<number>
@@ -799,15 +799,15 @@ var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunctio
 >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : Promise<number>
 >                                                                                                        : ^^^^^^^^^^^^^^^
 >s3.then(testFunction3P, testFunction3, testFunction3).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                           : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                           : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3.then(testFunction3P, testFunction3, testFunction3) : Promise<IPromise<number>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3P : (x: number) => Promise<number>
 >               : ^ ^^      ^^^^^               
 >testFunction3 : (x: number) => IPromise<number>
@@ -815,7 +815,7 @@ var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunctio
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -845,11 +845,11 @@ var r4a = r4.then(testFunction4, testFunction4, testFunction4); // error
 >r4.then(testFunction4, testFunction4, testFunction4) : IPromise<string>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r4.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r4 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >              : ^ ^^      ^^ ^^^      ^^^^^                
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -863,15 +863,15 @@ var r4b = r4.then(sIPromise, testFunction4, testFunction4).then(sIPromise, testF
 >r4.then(sIPromise, testFunction4, testFunction4).then(sIPromise, testFunction4, testFunction4) : IPromise<string>
 >                                                                                               : ^^^^^^^^^^^^^^^^
 >r4.then(sIPromise, testFunction4, testFunction4).then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                                      : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                                      : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r4.then(sIPromise, testFunction4, testFunction4) : IPromise<string>
 >                                                 : ^^^^^^^^^^^^^^^^
 >r4.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r4 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -879,7 +879,7 @@ var r4b = r4.then(sIPromise, testFunction4, testFunction4).then(sIPromise, testF
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >              : ^ ^^      ^^ ^^^      ^^^^^                
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -897,11 +897,11 @@ var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 >s4.then(testFunction4, testFunction4, testFunction4) : Promise<string>
 >                                                     : ^^^^^^^^^^^^^^^
 >s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >              : ^ ^^      ^^ ^^^      ^^^^^                
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -915,11 +915,11 @@ var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error
 >s4.then(testFunction4P, testFunction4P, testFunction4P) : Promise<string>
 >                                                        : ^^^^^^^^^^^^^^^
 >s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >               : ^ ^^      ^^ ^^^      ^^^^^               
 >testFunction4P : (x: number, y?: string) => Promise<string>
@@ -933,11 +933,11 @@ var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
 >s4.then(testFunction4P, testFunction4, testFunction4) : Promise<string>
 >                                                      : ^^^^^^^^^^^^^^^
 >s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >               : ^ ^^      ^^ ^^^      ^^^^^               
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -951,15 +951,15 @@ var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, test
 >s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4) : Promise<IPromise<string>>
 >                                                                                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s4.then(sIPromise, testFunction4P, testFunction4).then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: IPromise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                       : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                       : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4.then(sIPromise, testFunction4P, testFunction4) : Promise<IPromise<string>>
 >                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >testFunction4P : (x: number, y?: string) => Promise<string>
@@ -967,7 +967,7 @@ var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, test
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >              : ^ ^^      ^^ ^^^      ^^^^^                
 >then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: IPromise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >testFunction4P : (x: number, y?: string) => Promise<string>
@@ -985,11 +985,11 @@ var r5a = r5.then(testFunction5, testFunction5, testFunction5); // error
 >r5.then(testFunction5, testFunction5, testFunction5) : IPromise<string>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r5.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r5 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >              : ^ ^^      ^^  ^^                     ^^^^^                
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -1003,15 +1003,15 @@ var r5b = r5.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >r5.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                                                               : ^^^^^^^^^^^^^^^^
 >r5.then(sIPromise, sIPromise, sIPromise).then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r5.then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                         : ^^^^^^^^^^^^^^^^
 >r5.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r5 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1019,7 +1019,7 @@ var r5b = r5.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1037,11 +1037,11 @@ var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error
 >s5.then(testFunction5, testFunction5, testFunction5) : Promise<string>
 >                                                     : ^^^^^^^^^^^^^^^
 >s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >              : ^ ^^      ^^  ^^                     ^^^^^                
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -1055,11 +1055,11 @@ var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error
 >s5.then(testFunction5P, testFunction5P, testFunction5P) : Promise<string>
 >                                                        : ^^^^^^^^^^^^^^^
 >s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >               : ^ ^^      ^^  ^^                     ^^^^^               
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
@@ -1073,11 +1073,11 @@ var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error
 >s5.then(testFunction5P, testFunction5, testFunction5) : Promise<string>
 >                                                      : ^^^^^^^^^^^^^^^
 >s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >               : ^ ^^      ^^  ^^                     ^^^^^               
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -1091,15 +1091,15 @@ var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro
 >s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
 >                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s5.then(sPromise, sPromise, sPromise).then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                           : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                           : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5.then(sPromise, sPromise, sPromise) : Promise<string>
 >                                      : ^^^^^^^^^^^^^^^
 >s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1107,7 +1107,7 @@ var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1125,11 +1125,11 @@ var r6a = r6.then(testFunction6, testFunction6, testFunction6); // error
 >r6.then(testFunction6, testFunction6, testFunction6) : IPromise<string>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r6.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r6 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >              : ^ ^^      ^^  ^^              ^^^^^                
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -1143,15 +1143,15 @@ var r6b = r6.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >r6.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                                                               : ^^^^^^^^^^^^^^^^
 >r6.then(sIPromise, sIPromise, sIPromise).then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r6.then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                         : ^^^^^^^^^^^^^^^^
 >r6.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r6 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1159,7 +1159,7 @@ var r6b = r6.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1177,11 +1177,11 @@ var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error
 >s6.then(testFunction6, testFunction6, testFunction6) : Promise<string>
 >                                                     : ^^^^^^^^^^^^^^^
 >s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >              : ^ ^^      ^^  ^^              ^^^^^                
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -1195,11 +1195,11 @@ var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error
 >s6.then(testFunction6P, testFunction6P, testFunction6P) : Promise<string>
 >                                                        : ^^^^^^^^^^^^^^^
 >s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >               : ^ ^^      ^^  ^^              ^^^^^               
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
@@ -1213,11 +1213,11 @@ var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error
 >s6.then(testFunction6P, testFunction6, testFunction6) : Promise<string>
 >                                                      : ^^^^^^^^^^^^^^^
 >s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >               : ^ ^^      ^^  ^^              ^^^^^               
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -1231,15 +1231,15 @@ var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro
 >s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
 >                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s6.then(sPromise, sPromise, sPromise).then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                           : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                           : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6.then(sPromise, sPromise, sPromise) : Promise<string>
 >                                      : ^^^^^^^^^^^^^^^
 >s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1247,7 +1247,7 @@ var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1265,11 +1265,11 @@ var r7a = r7.then(testFunction7, testFunction7, testFunction7); // error
 >r7.then(testFunction7, testFunction7, testFunction7) : IPromise<string>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r7.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
 >              : ^  ^^              ^^^^^                
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
@@ -1283,15 +1283,15 @@ var r7b = r7.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >r7.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                                                               : ^^^^^^^^^^^^^^^^
 >r7.then(sIPromise, sIPromise, sIPromise).then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7.then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                         : ^^^^^^^^^^^^^^^^
 >r7.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1299,7 +1299,7 @@ var r7b = r7.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1317,11 +1317,11 @@ var s7a = r7.then(testFunction7, testFunction7, testFunction7); // error
 >r7.then(testFunction7, testFunction7, testFunction7) : IPromise<string>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r7.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
 >              : ^  ^^              ^^^^^                
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
@@ -1335,11 +1335,11 @@ var s7b = r7.then(testFunction7P, testFunction7P, testFunction7P); // error
 >r7.then(testFunction7P, testFunction7P, testFunction7P) : IPromise<string>
 >                                                        : ^^^^^^^^^^^^^^^^
 >r7.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction7P : (cb: <T>(a: T) => T) => Promise<string>
 >               : ^  ^^              ^^^^^               
 >testFunction7P : (cb: <T>(a: T) => T) => Promise<string>
@@ -1353,11 +1353,11 @@ var s7c = r7.then(testFunction7P, testFunction7, testFunction7); // error
 >r7.then(testFunction7P, testFunction7, testFunction7) : IPromise<string>
 >                                                      : ^^^^^^^^^^^^^^^^
 >r7.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction7P : (cb: <T>(a: T) => T) => Promise<string>
 >               : ^  ^^              ^^^^^               
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
@@ -1371,15 +1371,15 @@ var s7d = r7.then(sPromise, sPromise, sPromise).then(sPromise, sPromise, sPromis
 >r7.then(sPromise, sPromise, sPromise).then(sPromise, sPromise, sPromise) : IPromise<string>
 >                                                                         : ^^^^^^^^^^^^^^^^
 >r7.then(sPromise, sPromise, sPromise).then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                           : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                           : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7.then(sPromise, sPromise, sPromise) : IPromise<string>
 >                                      : ^^^^^^^^^^^^^^^^
 >r7.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1387,7 +1387,7 @@ var s7d = r7.then(sPromise, sPromise, sPromise).then(sPromise, sPromise, sPromis
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1417,11 +1417,11 @@ var r8a = r8.then(testFunction8, testFunction8, testFunction8); // error
 >r8.then(testFunction8, testFunction8, testFunction8) : IPromise<unknown>
 >                                                     : ^^^^^^^^^^^^^^^^^
 >r8.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r8 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >              : ^ ^^ ^^ ^^  ^^           ^^^^^           
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -1435,15 +1435,15 @@ var r8b = r8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI
 >r8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : IPromise<number>
 >                                                                               : ^^^^^^^^^^^^^^^^
 >r8.then(nIPromise, nIPromise, nIPromise).then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r8.then(nIPromise, nIPromise, nIPromise) : IPromise<number>
 >                                         : ^^^^^^^^^^^^^^^^
 >r8.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r8 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1451,7 +1451,7 @@ var r8b = r8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1469,11 +1469,11 @@ var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error
 >s8.then(testFunction8, testFunction8, testFunction8) : Promise<unknown>
 >                                                     : ^^^^^^^^^^^^^^^^
 >s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >              : ^ ^^ ^^ ^^  ^^           ^^^^^           
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -1487,11 +1487,11 @@ var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error
 >s8.then(testFunction8P, testFunction8P, testFunction8P) : Promise<unknown>
 >                                                        : ^^^^^^^^^^^^^^^^
 >s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >               : ^ ^^ ^^ ^^  ^^           ^^^^^          
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
@@ -1505,11 +1505,11 @@ var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error
 >s8.then(testFunction8P, testFunction8, testFunction8) : Promise<unknown>
 >                                                      : ^^^^^^^^^^^^^^^^
 >s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >               : ^ ^^ ^^ ^^  ^^           ^^^^^          
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -1523,15 +1523,15 @@ var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI
 >s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : Promise<IPromise<number>>
 >                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s8.then(nIPromise, nIPromise, nIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                              : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                              : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8.then(nIPromise, nIPromise, nIPromise) : Promise<IPromise<number>>
 >                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1539,7 +1539,7 @@ var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1557,11 +1557,11 @@ var r9a = r9.then(testFunction9, testFunction9, testFunction9); // error
 >r9.then(testFunction9, testFunction9, testFunction9) : IPromise<unknown>
 >                                                     : ^^^^^^^^^^^^^^^^^
 >r9.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >              : ^ ^^ ^^ ^^  ^^              ^^^^^           
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -1575,11 +1575,11 @@ var r9b = r9.then(sIPromise, sIPromise, sIPromise); // ok
 >r9.then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                         : ^^^^^^^^^^^^^^^^
 >r9.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1593,11 +1593,11 @@ var r9c = r9.then(nIPromise, nIPromise, nIPromise); // ok
 >r9.then(nIPromise, nIPromise, nIPromise) : IPromise<number>
 >                                         : ^^^^^^^^^^^^^^^^
 >r9.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1611,11 +1611,11 @@ var r9d = r9.then(testFunction, sIPromise, nIPromise); // ok
 >r9.then(testFunction, sIPromise, nIPromise) : IPromise<number>
 >                                            : ^^^^^^^^^^^^^^^^
 >r9.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1629,15 +1629,15 @@ var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise,
 >r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                                                                  : ^^^^^^^^^^^^^^^^
 >r9.then(testFunction, nIPromise, sIPromise).then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                                 : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                                 : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r9.then(testFunction, nIPromise, sIPromise) : IPromise<number>
 >                                            : ^^^^^^^^^^^^^^^^
 >r9.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1645,7 +1645,7 @@ var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise,
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1663,11 +1663,11 @@ var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
 >s9.then(testFunction9, testFunction9, testFunction9) : Promise<unknown>
 >                                                     : ^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >              : ^ ^^ ^^ ^^  ^^              ^^^^^           
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -1681,11 +1681,11 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 >s9.then(testFunction9P, testFunction9P, testFunction9P) : Promise<unknown>
 >                                                        : ^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >               : ^ ^^ ^^ ^^  ^^              ^^^^^          
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
@@ -1699,11 +1699,11 @@ var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 >s9.then(testFunction9P, testFunction9, testFunction9) : Promise<unknown>
 >                                                      : ^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >               : ^ ^^ ^^ ^^  ^^              ^^^^^          
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -1717,11 +1717,11 @@ var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 >s9.then(sPromise, sPromise, sPromise) : Promise<string>
 >                                      : ^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1735,11 +1735,11 @@ var s9e = s9.then(nPromise, nPromise, nPromise); // ok
 >s9.then(nPromise, nPromise, nPromise) : Promise<number>
 >                                      : ^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >nPromise : (x: any) => Promise<number>
 >         : ^ ^^   ^^^^^               
 >nPromise : (x: any) => Promise<number>
@@ -1753,11 +1753,11 @@ var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 >s9.then(testFunction, sIPromise, nIPromise) : Promise<number>
 >                                            : ^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1771,15 +1771,15 @@ var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise,
 >s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
 >                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s9.then(testFunction, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                 : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                 : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9.then(testFunction, nIPromise, sIPromise) : Promise<IPromise<number>>
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1787,7 +1787,7 @@ var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise,
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1815,11 +1815,11 @@ var r10a = r10.then(testFunction10, testFunction10, testFunction10); // ok
 >r10.then(testFunction10, testFunction10, testFunction10) : IPromise<unknown>
 >                                                         : ^^^^^^^^^^^^^^^^^
 >r10.then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >               : ^ ^^  ^^              ^^^^^           
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1833,11 +1833,11 @@ var r10b = r10.then(sIPromise, sIPromise, sIPromise); // ok
 >r10.then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                          : ^^^^^^^^^^^^^^^^
 >r10.then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1851,11 +1851,11 @@ var r10c = r10.then(nIPromise, nIPromise, nIPromise); // ok
 >r10.then(nIPromise, nIPromise, nIPromise) : IPromise<number>
 >                                          : ^^^^^^^^^^^^^^^^
 >r10.then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1869,11 +1869,11 @@ var r10d = r10.then(testFunction, sIPromise, nIPromise); // ok
 >r10.then(testFunction, sIPromise, nIPromise) : IPromise<number>
 >                                             : ^^^^^^^^^^^^^^^^
 >r10.then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1887,15 +1887,15 @@ var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromis
 >r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                                                                   : ^^^^^^^^^^^^^^^^
 >r10.then(testFunction, nIPromise, sIPromise).then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                                  : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                                  : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r10.then(testFunction, nIPromise, sIPromise) : IPromise<number>
 >                                             : ^^^^^^^^^^^^^^^^
 >r10.then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1903,7 +1903,7 @@ var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromis
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1931,11 +1931,11 @@ var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
 >s10.then(testFunction10, testFunction10, testFunction10) : Promise<IPromise<unknown>>
 >                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >               : ^ ^^  ^^              ^^^^^           
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1949,11 +1949,11 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 >s10.then(testFunction10P, testFunction10P, testFunction10P) : Promise<unknown>
 >                                                            : ^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >                : ^ ^^  ^^              ^^^^^          
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
@@ -1967,11 +1967,11 @@ var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 >s10.then(testFunction10P, testFunction10, testFunction10) : Promise<unknown>
 >                                                          : ^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >                : ^ ^^  ^^              ^^^^^          
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1985,11 +1985,11 @@ var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 >s10.then(sPromise, sPromise, sPromise) : Promise<string>
 >                                       : ^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -2003,11 +2003,11 @@ var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
 >s10.then(nIPromise, nPromise, nIPromise) : Promise<IPromise<number>>
 >                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nPromise : (x: any) => Promise<number>
@@ -2021,11 +2021,11 @@ var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 >s10.then(testFunctionP, sIPromise, nIPromise) : Promise<number>
 >                                              : ^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >sIPromise : (x: any) => IPromise<string>
@@ -2039,15 +2039,15 @@ var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromis
 >s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
 >                                                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then(testFunctionP, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                   : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                   : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10.then(testFunctionP, nIPromise, sIPromise) : Promise<IPromise<number>>
 >                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >nIPromise : (x: any) => IPromise<number>
@@ -2055,7 +2055,7 @@ var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromis
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sIPromise : (x: any) => IPromise<string>
@@ -2073,11 +2073,11 @@ var r11a = r11.then(testFunction11, testFunction11, testFunction11); // error
 >r11.then(testFunction11, testFunction11, testFunction11) : IPromise<string>
 >                                                         : ^^^^^^^^^^^^^^^^
 >r11.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r11 : IPromise<number>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >               : ^^^ ^^      ^^^                ^^^ ^^      ^^^                ^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
@@ -2095,11 +2095,11 @@ var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
 >s11.then(testFunction11, testFunction11, testFunction11) : Promise<string>
 >                                                         : ^^^^^^^^^^^^^^^
 >s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s11 : Promise<number>
 >    : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >               : ^^^ ^^      ^^^                ^^^ ^^      ^^^                ^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
@@ -2113,11 +2113,11 @@ var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
 >s11.then(testFunction11P, testFunction11P, testFunction11P) : Promise<string>
 >                                                            : ^^^^^^^^^^^^^^^
 >s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s11 : Promise<number>
 >    : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >                : ^^^ ^^      ^^^               ^^^ ^^      ^^^               ^^^
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
@@ -2131,11 +2131,11 @@ var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
 >s11.then(testFunction11P, testFunction11, testFunction11) : Promise<string>
 >                                                          : ^^^^^^^^^^^^^^^
 >s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s11 : Promise<number>
 >    : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >                : ^^^ ^^      ^^^               ^^^ ^^      ^^^               ^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
@@ -2163,11 +2163,11 @@ var r12a = r12.then(testFunction12, testFunction12, testFunction12); // ok
 >r12.then(testFunction12, testFunction12, testFunction12) : IPromise<unknown>
 >                                                         : ^^^^^^^^^^^^^^^^^
 >r12.then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r12 : IPromise<(x: any) => any>
 >    : ^^^^^^^^^^ ^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
 >               : ^^^ ^^ ^^ ^^^           ^^^ ^^ ^^ ^^ ^^ ^^^           ^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
@@ -2195,11 +2195,11 @@ var s12a = s12.then(testFunction12, testFunction12, testFunction12); // ok
 >s12.then(testFunction12, testFunction12, testFunction12) : IPromise<unknown>
 >                                                         : ^^^^^^^^^^^^^^^^^
 >s12.then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >s12 : IPromise<(x: any) => any>
 >    : ^^^^^^^^^^ ^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
 >               : ^^^ ^^ ^^ ^^^           ^^^ ^^ ^^ ^^ ^^ ^^^           ^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
@@ -2213,11 +2213,11 @@ var s12b = s12.then(testFunction12P, testFunction12P, testFunction12P); // ok
 >s12.then(testFunction12P, testFunction12P, testFunction12P) : IPromise<unknown>
 >                                                            : ^^^^^^^^^^^^^^^^^
 >s12.then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >s12 : IPromise<(x: any) => any>
 >    : ^^^^^^^^^^ ^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction12P : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }
 >                : ^^^ ^^ ^^ ^^^           ^^^ ^^ ^^ ^^ ^^ ^^^          ^^^
 >testFunction12P : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }
@@ -2231,11 +2231,11 @@ var s12c = s12.then(testFunction12P, testFunction12, testFunction12); // ok
 >s12.then(testFunction12P, testFunction12, testFunction12) : IPromise<unknown>
 >                                                          : ^^^^^^^^^^^^^^^^^
 >s12.then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >s12 : IPromise<(x: any) => any>
 >    : ^^^^^^^^^^ ^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction12P : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }
 >                : ^^^ ^^ ^^ ^^^           ^^^ ^^ ^^ ^^ ^^ ^^^          ^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
diff --git a/tests/baselines/reference/promisePermutations2.types b/tests/baselines/reference/promisePermutations2.types
index 2e0cd276c4d32..dade863dfdb7a 100644
--- a/tests/baselines/reference/promisePermutations2.types
+++ b/tests/baselines/reference/promisePermutations2.types
@@ -344,11 +344,11 @@ var r1a = r1.then(testFunction, testFunction, testFunction);
 >r1.then(testFunction, testFunction, testFunction) : IPromise<number>
 >                                                  : ^^^^^^^^^^^^^^^^
 >r1.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r1 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -362,15 +362,15 @@ var r1b = r1.then(testFunction, testFunction, testFunction).then(testFunction, t
 >r1.then(testFunction, testFunction, testFunction).then(testFunction, testFunction, testFunction) : IPromise<number>
 >                                                                                                 : ^^^^^^^^^^^^^^^^
 >r1.then(testFunction, testFunction, testFunction).then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                                       : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                                       : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r1.then(testFunction, testFunction, testFunction) : IPromise<number>
 >                                                  : ^^^^^^^^^^^^^^^^
 >r1.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r1 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -378,7 +378,7 @@ var r1b = r1.then(testFunction, testFunction, testFunction).then(testFunction, t
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -392,11 +392,11 @@ var r1c = r1.then(testFunctionP, testFunctionP, testFunctionP);
 >r1.then(testFunctionP, testFunctionP, testFunctionP) : IPromise<number>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r1.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r1 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >testFunctionP : () => Promise<number>
@@ -414,11 +414,11 @@ var s1a = s1.then(testFunction, testFunction, testFunction);
 >s1.then(testFunction, testFunction, testFunction) : Promise<IPromise<number>>
 >                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -432,11 +432,11 @@ var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP);
 >s1.then(testFunctionP, testFunctionP, testFunctionP) : Promise<Promise<number>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^
 >s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >testFunctionP : () => Promise<number>
@@ -450,11 +450,11 @@ var s1c = s1.then(testFunctionP, testFunction, testFunction);
 >s1.then(testFunctionP, testFunction, testFunction) : Promise<IPromise<number>>
 >                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >testFunction : () => IPromise<number>
@@ -468,15 +468,15 @@ var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction,
 >s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction) : Promise<IPromise<number>>
 >                                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s1.then(testFunctionP, testFunction, testFunction).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                        : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                        : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1.then(testFunctionP, testFunction, testFunction) : Promise<IPromise<number>>
 >                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >testFunction : () => IPromise<number>
@@ -484,7 +484,7 @@ var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction,
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -504,11 +504,11 @@ var r2a = r2.then(testFunction2, testFunction2, testFunction2);
 >r2.then(testFunction2, testFunction2, testFunction2) : IPromise<{ x: number; }>
 >                                                     : ^^^^^^^^^^^^^^      ^^^^
 >r2.then : { <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r2 : IPromise<{ x: number; }>
 >   : ^^^^^^^^^^^^^^      ^^^^
 >then : { <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -522,15 +522,15 @@ var r2b = r2.then(testFunction2, testFunction2, testFunction2).then(testFunction
 >r2.then(testFunction2, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : IPromise<{ x: number; }>
 >                                                                                                       : ^^^^^^^^^^^^^^      ^^^^
 >r2.then(testFunction2, testFunction2, testFunction2).then : { <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                                          : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                                          : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r2.then(testFunction2, testFunction2, testFunction2) : IPromise<{ x: number; }>
 >                                                     : ^^^^^^^^^^^^^^      ^^^^
 >r2.then : { <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r2 : IPromise<{ x: number; }>
 >   : ^^^^^^^^^^^^^^      ^^^^
 >then : { <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -538,7 +538,7 @@ var r2b = r2.then(testFunction2, testFunction2, testFunction2).then(testFunction
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >then : { <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -558,11 +558,11 @@ var s2a = s2.then(testFunction2, testFunction2, testFunction2);
 >s2.then(testFunction2, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2 : Promise<{ x: number; }>
 >   : ^^^^^^^^^^^^^      ^^^^
 >then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -576,11 +576,11 @@ var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P);
 >s2.then(testFunction2P, testFunction2P, testFunction2P) : Promise<Promise<{ x: number; }>>
 >                                                        : ^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2 : Promise<{ x: number; }>
 >   : ^^^^^^^^^^^^^      ^^^^
 >then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2P : () => Promise<{ x: number; }>
 >               : ^^^^^^                       
 >testFunction2P : () => Promise<{ x: number; }>
@@ -594,11 +594,11 @@ var s2c = s2.then(testFunction2P, testFunction2, testFunction2);
 >s2.then(testFunction2P, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2 : Promise<{ x: number; }>
 >   : ^^^^^^^^^^^^^      ^^^^
 >then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2P : () => Promise<{ x: number; }>
 >               : ^^^^^^                       
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -612,15 +612,15 @@ var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunctio
 >s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
 >                                                                                                        : ^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >s2.then(testFunction2P, testFunction2, testFunction2).then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                           : ^^^        ^^^^^^^^^^^^^^^^^      ^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                           : ^^^        ^^^^^^^^^^^^^^^^^      ^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2.then(testFunction2P, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2 : Promise<{ x: number; }>
 >   : ^^^^^^^^^^^^^      ^^^^
 >then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2P : () => Promise<{ x: number; }>
 >               : ^^^^^^                       
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -628,7 +628,7 @@ var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunctio
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^      ^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^      ^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -646,11 +646,11 @@ var r3a = r3.then(testFunction3, testFunction3, testFunction3);
 >r3.then(testFunction3, testFunction3, testFunction3) : IPromise<number>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r3.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r3 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -664,15 +664,15 @@ var r3b = r3.then(testFunction3, testFunction3, testFunction3).then(testFunction
 >r3.then(testFunction3, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : IPromise<number>
 >                                                                                                       : ^^^^^^^^^^^^^^^^
 >r3.then(testFunction3, testFunction3, testFunction3).then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                                          : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                                          : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r3.then(testFunction3, testFunction3, testFunction3) : IPromise<number>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r3.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r3 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -680,7 +680,7 @@ var r3b = r3.then(testFunction3, testFunction3, testFunction3).then(testFunction
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -698,11 +698,11 @@ var s3a = s3.then(testFunction3, testFunction3, testFunction3);
 >s3.then(testFunction3, testFunction3, testFunction3) : Promise<IPromise<number>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -716,11 +716,11 @@ var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
 >s3.then(testFunction3P, testFunction3P, testFunction3P) : Promise<Promise<number>>
 >                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^
 >s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3P : (x: number) => Promise<number>
 >               : ^ ^^      ^^^^^               
 >testFunction3P : (x: number) => Promise<number>
@@ -734,11 +734,11 @@ var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
 >s3.then(testFunction3P, testFunction3, testFunction3) : Promise<IPromise<number>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3P : (x: number) => Promise<number>
 >               : ^ ^^      ^^^^^               
 >testFunction3 : (x: number) => IPromise<number>
@@ -752,15 +752,15 @@ var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunctio
 >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : Promise<IPromise<number>>
 >                                                                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s3.then(testFunction3P, testFunction3, testFunction3).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                           : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                           : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3.then(testFunction3P, testFunction3, testFunction3) : Promise<IPromise<number>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3P : (x: number) => Promise<number>
 >               : ^ ^^      ^^^^^               
 >testFunction3 : (x: number) => IPromise<number>
@@ -768,7 +768,7 @@ var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunctio
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -798,11 +798,11 @@ var r4a = r4.then(testFunction4, testFunction4, testFunction4); // error
 >r4.then(testFunction4, testFunction4, testFunction4) : IPromise<string>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r4.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r4 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >              : ^ ^^      ^^ ^^^      ^^^^^                
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -816,15 +816,15 @@ var r4b = r4.then(sIPromise, testFunction4, testFunction4).then(sIPromise, testF
 >r4.then(sIPromise, testFunction4, testFunction4).then(sIPromise, testFunction4, testFunction4) : IPromise<string>
 >                                                                                               : ^^^^^^^^^^^^^^^^
 >r4.then(sIPromise, testFunction4, testFunction4).then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                                      : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                                      : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r4.then(sIPromise, testFunction4, testFunction4) : IPromise<string>
 >                                                 : ^^^^^^^^^^^^^^^^
 >r4.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r4 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -832,7 +832,7 @@ var r4b = r4.then(sIPromise, testFunction4, testFunction4).then(sIPromise, testF
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >              : ^ ^^      ^^ ^^^      ^^^^^                
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -850,11 +850,11 @@ var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 >s4.then(testFunction4, testFunction4, testFunction4) : Promise<IPromise<string>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >              : ^ ^^      ^^ ^^^      ^^^^^                
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -868,11 +868,11 @@ var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error
 >s4.then(testFunction4P, testFunction4P, testFunction4P) : Promise<Promise<string>>
 >                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^
 >s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >               : ^ ^^      ^^ ^^^      ^^^^^               
 >testFunction4P : (x: number, y?: string) => Promise<string>
@@ -886,11 +886,11 @@ var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
 >s4.then(testFunction4P, testFunction4, testFunction4) : Promise<IPromise<string>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >               : ^ ^^      ^^ ^^^      ^^^^^               
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -904,15 +904,15 @@ var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, test
 >s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4) : Promise<IPromise<string>>
 >                                                                                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s4.then(sIPromise, testFunction4P, testFunction4).then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: IPromise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                       : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                       : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4.then(sIPromise, testFunction4P, testFunction4) : Promise<IPromise<string>>
 >                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >testFunction4P : (x: number, y?: string) => Promise<string>
@@ -920,7 +920,7 @@ var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, test
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >              : ^ ^^      ^^ ^^^      ^^^^^                
 >then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: IPromise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >testFunction4P : (x: number, y?: string) => Promise<string>
@@ -938,11 +938,11 @@ var r5a = r5.then(testFunction5, testFunction5, testFunction5); // error
 >r5.then(testFunction5, testFunction5, testFunction5) : IPromise<string>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r5.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r5 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >              : ^ ^^      ^^  ^^                     ^^^^^                
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -956,15 +956,15 @@ var r5b = r5.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >r5.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                                                               : ^^^^^^^^^^^^^^^^
 >r5.then(sIPromise, sIPromise, sIPromise).then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r5.then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                         : ^^^^^^^^^^^^^^^^
 >r5.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r5 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -972,7 +972,7 @@ var r5b = r5.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -990,11 +990,11 @@ var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error
 >s5.then(testFunction5, testFunction5, testFunction5) : Promise<IPromise<string>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >              : ^ ^^      ^^  ^^                     ^^^^^                
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -1008,11 +1008,11 @@ var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error
 >s5.then(testFunction5P, testFunction5P, testFunction5P) : Promise<Promise<string>>
 >                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^
 >s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >               : ^ ^^      ^^  ^^                     ^^^^^               
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
@@ -1026,11 +1026,11 @@ var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error
 >s5.then(testFunction5P, testFunction5, testFunction5) : Promise<IPromise<string>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >               : ^ ^^      ^^  ^^                     ^^^^^               
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -1044,15 +1044,15 @@ var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro
 >s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
 >                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s5.then(sPromise, sPromise, sPromise).then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: Promise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                           : ^^^        ^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                           : ^^^        ^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5.then(sPromise, sPromise, sPromise) : Promise<Promise<string>>
 >                                      : ^^^^^^^^^^^^^^^^^^^^^^^^
 >s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1060,7 +1060,7 @@ var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: Promise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1078,11 +1078,11 @@ var r6a = r6.then(testFunction6, testFunction6, testFunction6); // error
 >r6.then(testFunction6, testFunction6, testFunction6) : IPromise<string>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r6.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r6 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >              : ^ ^^      ^^  ^^              ^^^^^                
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -1096,15 +1096,15 @@ var r6b = r6.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >r6.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                                                               : ^^^^^^^^^^^^^^^^
 >r6.then(sIPromise, sIPromise, sIPromise).then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r6.then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                         : ^^^^^^^^^^^^^^^^
 >r6.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r6 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1112,7 +1112,7 @@ var r6b = r6.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1130,11 +1130,11 @@ var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error
 >s6.then(testFunction6, testFunction6, testFunction6) : Promise<IPromise<string>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >              : ^ ^^      ^^  ^^              ^^^^^                
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -1148,11 +1148,11 @@ var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error
 >s6.then(testFunction6P, testFunction6P, testFunction6P) : Promise<Promise<string>>
 >                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^
 >s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >               : ^ ^^      ^^  ^^              ^^^^^               
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
@@ -1166,11 +1166,11 @@ var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error
 >s6.then(testFunction6P, testFunction6, testFunction6) : Promise<IPromise<string>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >               : ^ ^^      ^^  ^^              ^^^^^               
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -1184,15 +1184,15 @@ var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro
 >s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
 >                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s6.then(sPromise, sPromise, sPromise).then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: Promise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                           : ^^^        ^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                           : ^^^        ^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6.then(sPromise, sPromise, sPromise) : Promise<Promise<string>>
 >                                      : ^^^^^^^^^^^^^^^^^^^^^^^^
 >s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1200,7 +1200,7 @@ var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >then : { <TResult1 = Promise<string>, TResult2 = never>(onfulfilled?: (value: Promise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1218,11 +1218,11 @@ var r7a = r7.then(testFunction7, testFunction7, testFunction7); // error
 >r7.then(testFunction7, testFunction7, testFunction7) : IPromise<string>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r7.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
 >              : ^  ^^              ^^^^^                
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
@@ -1236,15 +1236,15 @@ var r7b = r7.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >r7.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                                                               : ^^^^^^^^^^^^^^^^
 >r7.then(sIPromise, sIPromise, sIPromise).then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7.then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                         : ^^^^^^^^^^^^^^^^
 >r7.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1252,7 +1252,7 @@ var r7b = r7.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1270,11 +1270,11 @@ var s7a = r7.then(testFunction7, testFunction7, testFunction7); // error
 >r7.then(testFunction7, testFunction7, testFunction7) : IPromise<string>
 >                                                     : ^^^^^^^^^^^^^^^^
 >r7.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
 >              : ^  ^^              ^^^^^                
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
@@ -1288,11 +1288,11 @@ var s7b = r7.then(testFunction7P, testFunction7P, testFunction7P); // error
 >r7.then(testFunction7P, testFunction7P, testFunction7P) : IPromise<string>
 >                                                        : ^^^^^^^^^^^^^^^^
 >r7.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction7P : (cb: <T>(a: T) => T) => Promise<string>
 >               : ^  ^^              ^^^^^               
 >testFunction7P : (cb: <T>(a: T) => T) => Promise<string>
@@ -1306,11 +1306,11 @@ var s7c = r7.then(testFunction7P, testFunction7, testFunction7); // error
 >r7.then(testFunction7P, testFunction7, testFunction7) : IPromise<string>
 >                                                      : ^^^^^^^^^^^^^^^^
 >r7.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction7P : (cb: <T>(a: T) => T) => Promise<string>
 >               : ^  ^^              ^^^^^               
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
@@ -1324,15 +1324,15 @@ var s7d = r7.then(sPromise, sPromise, sPromise).then(sPromise, sPromise, sPromis
 >r7.then(sPromise, sPromise, sPromise).then(sPromise, sPromise, sPromise) : IPromise<string>
 >                                                                         : ^^^^^^^^^^^^^^^^
 >r7.then(sPromise, sPromise, sPromise).then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                           : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                           : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7.then(sPromise, sPromise, sPromise) : IPromise<string>
 >                                      : ^^^^^^^^^^^^^^^^
 >r7.then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1340,7 +1340,7 @@ var s7d = r7.then(sPromise, sPromise, sPromise).then(sPromise, sPromise, sPromis
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >then : { <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1370,11 +1370,11 @@ var r8a = r8.then(testFunction8, testFunction8, testFunction8); // error
 >r8.then(testFunction8, testFunction8, testFunction8) : IPromise<unknown>
 >                                                     : ^^^^^^^^^^^^^^^^^
 >r8.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r8 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >              : ^ ^^ ^^ ^^  ^^           ^^^^^           
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -1388,15 +1388,15 @@ var r8b = r8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI
 >r8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : IPromise<number>
 >                                                                               : ^^^^^^^^^^^^^^^^
 >r8.then(nIPromise, nIPromise, nIPromise).then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                              : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r8.then(nIPromise, nIPromise, nIPromise) : IPromise<number>
 >                                         : ^^^^^^^^^^^^^^^^
 >r8.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r8 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1404,7 +1404,7 @@ var r8b = r8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1422,11 +1422,11 @@ var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error
 >s8.then(testFunction8, testFunction8, testFunction8) : Promise<unknown>
 >                                                     : ^^^^^^^^^^^^^^^^
 >s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >              : ^ ^^ ^^ ^^  ^^           ^^^^^           
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -1440,11 +1440,11 @@ var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error
 >s8.then(testFunction8P, testFunction8P, testFunction8P) : Promise<unknown>
 >                                                        : ^^^^^^^^^^^^^^^^
 >s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >               : ^ ^^ ^^ ^^  ^^           ^^^^^          
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
@@ -1458,11 +1458,11 @@ var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error
 >s8.then(testFunction8P, testFunction8, testFunction8) : Promise<unknown>
 >                                                      : ^^^^^^^^^^^^^^^^
 >s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >               : ^ ^^ ^^ ^^  ^^           ^^^^^          
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -1476,15 +1476,15 @@ var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI
 >s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : Promise<IPromise<number>>
 >                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s8.then(nIPromise, nIPromise, nIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                              : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                              : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8.then(nIPromise, nIPromise, nIPromise) : Promise<IPromise<number>>
 >                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1492,7 +1492,7 @@ var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1510,11 +1510,11 @@ var r9a = r9.then(testFunction9, testFunction9, testFunction9); // error
 >r9.then(testFunction9, testFunction9, testFunction9) : IPromise<unknown>
 >                                                     : ^^^^^^^^^^^^^^^^^
 >r9.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >              : ^ ^^ ^^ ^^  ^^              ^^^^^           
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -1528,11 +1528,11 @@ var r9b = r9.then(sIPromise, sIPromise, sIPromise); // ok
 >r9.then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                         : ^^^^^^^^^^^^^^^^
 >r9.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1546,11 +1546,11 @@ var r9c = r9.then(nIPromise, nIPromise, nIPromise); // ok
 >r9.then(nIPromise, nIPromise, nIPromise) : IPromise<number>
 >                                         : ^^^^^^^^^^^^^^^^
 >r9.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1564,11 +1564,11 @@ var r9d = r9.then(testFunction, sIPromise, nIPromise); // error
 >r9.then(testFunction, sIPromise, nIPromise) : IPromise<number>
 >                                            : ^^^^^^^^^^^^^^^^
 >r9.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1582,15 +1582,15 @@ var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise,
 >r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                                                                  : ^^^^^^^^^^^^^^^^
 >r9.then(testFunction, nIPromise, sIPromise).then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                                 : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                                 : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r9.then(testFunction, nIPromise, sIPromise) : IPromise<number>
 >                                            : ^^^^^^^^^^^^^^^^
 >r9.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>        : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1598,7 +1598,7 @@ var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise,
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1616,11 +1616,11 @@ var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
 >s9.then(testFunction9, testFunction9, testFunction9) : Promise<unknown>
 >                                                     : ^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >              : ^ ^^ ^^ ^^  ^^              ^^^^^           
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -1634,11 +1634,11 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 >s9.then(testFunction9P, testFunction9P, testFunction9P) : Promise<unknown>
 >                                                        : ^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >               : ^ ^^ ^^ ^^  ^^              ^^^^^          
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
@@ -1652,11 +1652,11 @@ var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 >s9.then(testFunction9P, testFunction9, testFunction9) : Promise<unknown>
 >                                                      : ^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >               : ^ ^^ ^^ ^^  ^^              ^^^^^          
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -1670,11 +1670,11 @@ var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 >s9.then(sPromise, sPromise, sPromise) : Promise<Promise<string>>
 >                                      : ^^^^^^^^^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1688,11 +1688,11 @@ var s9e = s9.then(nPromise, nPromise, nPromise); // ok
 >s9.then(nPromise, nPromise, nPromise) : Promise<Promise<number>>
 >                                      : ^^^^^^^^^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >nPromise : (x: any) => Promise<number>
 >         : ^ ^^   ^^^^^               
 >nPromise : (x: any) => Promise<number>
@@ -1706,11 +1706,11 @@ var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 >s9.then(testFunction, sIPromise, nIPromise) : Promise<IPromise<number>>
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1724,15 +1724,15 @@ var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise,
 >s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
 >                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s9.then(testFunction, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                 : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                 : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9.then(testFunction, nIPromise, sIPromise) : Promise<IPromise<number>>
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1740,7 +1740,7 @@ var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise,
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1768,11 +1768,11 @@ var r10a = r10.then(testFunction10, testFunction10, testFunction10); // ok
 >r10.then(testFunction10, testFunction10, testFunction10) : IPromise<unknown>
 >                                                         : ^^^^^^^^^^^^^^^^^
 >r10.then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >               : ^ ^^  ^^              ^^^^^           
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1786,11 +1786,11 @@ var r10b = r10.then(sIPromise, sIPromise, sIPromise); // ok
 >r10.then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                          : ^^^^^^^^^^^^^^^^
 >r10.then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1804,11 +1804,11 @@ var r10c = r10.then(nIPromise, nIPromise, nIPromise); // ok
 >r10.then(nIPromise, nIPromise, nIPromise) : IPromise<number>
 >                                          : ^^^^^^^^^^^^^^^^
 >r10.then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1822,11 +1822,11 @@ var r10d = r10.then(testFunction, sIPromise, nIPromise); // error
 >r10.then(testFunction, sIPromise, nIPromise) : IPromise<number>
 >                                             : ^^^^^^^^^^^^^^^^
 >r10.then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1840,15 +1840,15 @@ var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromis
 >r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<string>
 >                                                                                   : ^^^^^^^^^^^^^^^^
 >r10.then(testFunction, nIPromise, sIPromise).then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->                                                  : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>                                                  : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r10.then(testFunction, nIPromise, sIPromise) : IPromise<number>
 >                                             : ^^^^^^^^^^^^^^^^
 >r10.then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1856,7 +1856,7 @@ var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromis
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1884,11 +1884,11 @@ var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
 >s10.then(testFunction10, testFunction10, testFunction10) : Promise<IPromise<unknown>>
 >                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >               : ^ ^^  ^^              ^^^^^           
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1902,11 +1902,11 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 >s10.then(testFunction10P, testFunction10P, testFunction10P) : Promise<Promise<unknown>>
 >                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >                : ^ ^^  ^^              ^^^^^          
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
@@ -1920,11 +1920,11 @@ var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 >s10.then(testFunction10P, testFunction10, testFunction10) : Promise<IPromise<unknown>>
 >                                                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >                : ^ ^^  ^^              ^^^^^          
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1938,11 +1938,11 @@ var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 >s10.then(sPromise, sPromise, sPromise) : Promise<Promise<string>>
 >                                       : ^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1956,11 +1956,11 @@ var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
 >s10.then(nIPromise, nPromise, nIPromise) : Promise<IPromise<number>>
 >                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nPromise : (x: any) => Promise<number>
@@ -1974,11 +1974,11 @@ var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 >s10.then(testFunctionP, sIPromise, nIPromise) : Promise<Promise<number>>
 >                                              : ^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >sIPromise : (x: any) => IPromise<string>
@@ -1992,15 +1992,15 @@ var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromis
 >s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
 >                                                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then(testFunctionP, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                   : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                   : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10.then(testFunctionP, nIPromise, sIPromise) : Promise<IPromise<number>>
 >                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >nIPromise : (x: any) => IPromise<number>
@@ -2008,7 +2008,7 @@ var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromis
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sIPromise : (x: any) => IPromise<string>
@@ -2026,11 +2026,11 @@ var r11a = r11.then(testFunction11, testFunction11, testFunction11); // error
 >r11.then(testFunction11, testFunction11, testFunction11) : IPromise<string>
 >                                                         : ^^^^^^^^^^^^^^^^
 >r11.then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r11 : IPromise<number>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >               : ^^^ ^^      ^^^                ^^^ ^^      ^^^                ^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
@@ -2048,11 +2048,11 @@ var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
 >s11.then(testFunction11, testFunction11, testFunction11) : Promise<IPromise<string>>
 >                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s11 : Promise<number>
 >    : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >               : ^^^ ^^      ^^^                ^^^ ^^      ^^^                ^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
@@ -2066,11 +2066,11 @@ var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
 >s11.then(testFunction11P, testFunction11P, testFunction11P) : Promise<Promise<string>>
 >                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^
 >s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s11 : Promise<number>
 >    : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >                : ^^^ ^^      ^^^               ^^^ ^^      ^^^               ^^^
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
@@ -2084,11 +2084,11 @@ var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok
 >s11.then(testFunction11P, testFunction11, testFunction11) : Promise<IPromise<string>>
 >                                                          : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s11 : Promise<number>
 >    : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >                : ^^^ ^^      ^^^               ^^^ ^^      ^^^               ^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
@@ -2116,11 +2116,11 @@ var r12a = r12.then(testFunction12, testFunction12, testFunction12); // ok
 >r12.then(testFunction12, testFunction12, testFunction12) : IPromise<unknown>
 >                                                         : ^^^^^^^^^^^^^^^^^
 >r12.then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >r12 : IPromise<(x: any) => any>
 >    : ^^^^^^^^^^ ^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
 >               : ^^^ ^^ ^^ ^^^           ^^^ ^^ ^^ ^^ ^^ ^^^           ^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
@@ -2148,11 +2148,11 @@ var s12a = s12.then(testFunction12, testFunction12, testFunction12); // ok
 >s12.then(testFunction12, testFunction12, testFunction12) : IPromise<unknown>
 >                                                         : ^^^^^^^^^^^^^^^^^
 >s12.then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >s12 : IPromise<(x: any) => any>
 >    : ^^^^^^^^^^ ^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
 >               : ^^^ ^^ ^^ ^^^           ^^^ ^^ ^^ ^^ ^^ ^^^           ^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
@@ -2166,11 +2166,11 @@ var s12b = s12.then(testFunction12P, testFunction12P, testFunction12P); // ok
 >s12.then(testFunction12P, testFunction12P, testFunction12P) : IPromise<unknown>
 >                                                            : ^^^^^^^^^^^^^^^^^
 >s12.then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >s12 : IPromise<(x: any) => any>
 >    : ^^^^^^^^^^ ^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction12P : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }
 >                : ^^^ ^^ ^^ ^^^           ^^^ ^^ ^^ ^^ ^^ ^^^          ^^^
 >testFunction12P : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }
@@ -2184,11 +2184,11 @@ var s12c = s12.then(testFunction12P, testFunction12, testFunction12); // ok
 >s12.then(testFunction12P, testFunction12, testFunction12) : IPromise<unknown>
 >                                                          : ^^^^^^^^^^^^^^^^^
 >s12.then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>         : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >s12 : IPromise<(x: any) => any>
 >    : ^^^^^^^^^^ ^^^^^^^^^^^^^^
 >then : { <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
->     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^         ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^         ^ ^^        ^^^                       ^^^         ^ ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^         ^ ^^^
+>     : ^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^^
 >testFunction12P : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }
 >                : ^^^ ^^ ^^ ^^^           ^^^ ^^ ^^ ^^ ^^ ^^^          ^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
diff --git a/tests/baselines/reference/promisePermutations3.types b/tests/baselines/reference/promisePermutations3.types
index 818455a79b2f6..45ceb37d0d281 100644
--- a/tests/baselines/reference/promisePermutations3.types
+++ b/tests/baselines/reference/promisePermutations3.types
@@ -2,7 +2,7 @@
 
 === Performance Stats ===
 Type Count: 1,000
-Instantiation count: 5,000 -> 25,000
+Instantiation count: 5,000 -> 10,000
 
 === promisePermutations3.ts ===
 // same as promisePermutations but without the same overloads in IPromise<T>
@@ -345,11 +345,11 @@ var r1a = r1.then(testFunction, testFunction, testFunction);
 >r1.then(testFunction, testFunction, testFunction) : IPromise<IPromise<number>>
 >                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r1.then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r1 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -363,15 +363,15 @@ var r1b = r1.then(testFunction, testFunction, testFunction).then(testFunction, t
 >r1.then(testFunction, testFunction, testFunction).then(testFunction, testFunction, testFunction) : IPromise<IPromise<number>>
 >                                                                                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r1.then(testFunction, testFunction, testFunction).then : <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->                                                       : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>                                                       : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r1.then(testFunction, testFunction, testFunction) : IPromise<IPromise<number>>
 >                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r1.then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r1 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -379,7 +379,7 @@ var r1b = r1.then(testFunction, testFunction, testFunction).then(testFunction, t
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >then : <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -393,11 +393,11 @@ var r1c = r1.then(testFunctionP, testFunctionP, testFunctionP);
 >r1.then(testFunctionP, testFunctionP, testFunctionP) : IPromise<Promise<number>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >r1.then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r1 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >testFunctionP : () => Promise<number>
@@ -415,11 +415,11 @@ var s1a = s1.then(testFunction, testFunction, testFunction);
 >s1.then(testFunction, testFunction, testFunction) : Promise<IPromise<number>>
 >                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -433,11 +433,11 @@ var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP);
 >s1.then(testFunctionP, testFunctionP, testFunctionP) : Promise<number>
 >                                                     : ^^^^^^^^^^^^^^^
 >s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >testFunctionP : () => Promise<number>
@@ -451,11 +451,11 @@ var s1c = s1.then(testFunctionP, testFunction, testFunction);
 >s1.then(testFunctionP, testFunction, testFunction) : Promise<IPromise<number>>
 >                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >testFunction : () => IPromise<number>
@@ -469,15 +469,15 @@ var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction,
 >s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction) : Promise<IPromise<number>>
 >                                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s1.then(testFunctionP, testFunction, testFunction).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                        : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                        : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1.then(testFunctionP, testFunction, testFunction) : Promise<IPromise<number>>
 >                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s1.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s1 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >testFunction : () => IPromise<number>
@@ -485,7 +485,7 @@ var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction,
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >testFunction : () => IPromise<number>
@@ -505,11 +505,11 @@ var r2a = r2.then(testFunction2, testFunction2, testFunction2);
 >r2.then(testFunction2, testFunction2, testFunction2) : IPromise<IPromise<{ x: number; }>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >r2.then : <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r2 : IPromise<{ x: number; }>
 >   : ^^^^^^^^^^^^^^      ^^^^
 >then : <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -523,15 +523,15 @@ var r2b = r2.then(testFunction2, testFunction2, testFunction2).then(testFunction
 >r2.then(testFunction2, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : IPromise<IPromise<{ x: number; }>>
 >                                                                                                       : ^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >r2.then(testFunction2, testFunction2, testFunction2).then : <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->                                                          : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>                                                          : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r2.then(testFunction2, testFunction2, testFunction2) : IPromise<IPromise<{ x: number; }>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >r2.then : <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r2 : IPromise<{ x: number; }>
 >   : ^^^^^^^^^^^^^^      ^^^^
 >then : <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -539,7 +539,7 @@ var r2b = r2.then(testFunction2, testFunction2, testFunction2).then(testFunction
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >then : <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -559,11 +559,11 @@ var s2a = s2.then(testFunction2, testFunction2, testFunction2);
 >s2.then(testFunction2, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2 : Promise<{ x: number; }>
 >   : ^^^^^^^^^^^^^      ^^^^
 >then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -577,11 +577,11 @@ var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P);
 >s2.then(testFunction2P, testFunction2P, testFunction2P) : Promise<{ x: number; }>
 >                                                        : ^^^^^^^^^^^^^      ^^^^
 >s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2 : Promise<{ x: number; }>
 >   : ^^^^^^^^^^^^^      ^^^^
 >then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2P : () => Promise<{ x: number; }>
 >               : ^^^^^^                       
 >testFunction2P : () => Promise<{ x: number; }>
@@ -595,11 +595,11 @@ var s2c = s2.then(testFunction2P, testFunction2, testFunction2);
 >s2.then(testFunction2P, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2 : Promise<{ x: number; }>
 >   : ^^^^^^^^^^^^^      ^^^^
 >then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2P : () => Promise<{ x: number; }>
 >               : ^^^^^^                       
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -613,15 +613,15 @@ var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunctio
 >s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
 >                                                                                                        : ^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >s2.then(testFunction2P, testFunction2, testFunction2).then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                           : ^^^        ^^^^^^^^^^^^^^^^^      ^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                           : ^^^        ^^^^^^^^^^^^^^^^^      ^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2.then(testFunction2P, testFunction2, testFunction2) : Promise<IPromise<{ x: number; }>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^      ^^^^^
 >s2.then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s2 : Promise<{ x: number; }>
 >   : ^^^^^^^^^^^^^      ^^^^
 >then : { <TResult1 = { x: number; }, TResult2 = never>(onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^      ^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2P : () => Promise<{ x: number; }>
 >               : ^^^^^^                       
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -629,7 +629,7 @@ var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunctio
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >then : { <TResult1 = IPromise<{ x: number; }>, TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^      ^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^      ^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction2 : () => IPromise<{ x: number; }>
 >              : ^^^^^^                        
 >testFunction2 : () => IPromise<{ x: number; }>
@@ -647,11 +647,11 @@ var r3a = r3.then(testFunction3, testFunction3, testFunction3);
 >r3.then(testFunction3, testFunction3, testFunction3) : IPromise<IPromise<number>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r3.then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r3 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -665,15 +665,15 @@ var r3b = r3.then(testFunction3, testFunction3, testFunction3).then(testFunction
 >r3.then(testFunction3, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : IPromise<IPromise<number>>
 >                                                                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r3.then(testFunction3, testFunction3, testFunction3).then : <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->                                                          : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>                                                          : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r3.then(testFunction3, testFunction3, testFunction3) : IPromise<IPromise<number>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r3.then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r3 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -681,7 +681,7 @@ var r3b = r3.then(testFunction3, testFunction3, testFunction3).then(testFunction
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >then : <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -699,11 +699,11 @@ var s3a = s3.then(testFunction3, testFunction3, testFunction3);
 >s3.then(testFunction3, testFunction3, testFunction3) : Promise<IPromise<number>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -717,11 +717,11 @@ var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
 >s3.then(testFunction3P, testFunction3P, testFunction3P) : Promise<number>
 >                                                        : ^^^^^^^^^^^^^^^
 >s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3P : (x: number) => Promise<number>
 >               : ^ ^^      ^^^^^               
 >testFunction3P : (x: number) => Promise<number>
@@ -735,11 +735,11 @@ var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
 >s3.then(testFunction3P, testFunction3, testFunction3) : Promise<IPromise<number>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3P : (x: number) => Promise<number>
 >               : ^ ^^      ^^^^^               
 >testFunction3 : (x: number) => IPromise<number>
@@ -753,15 +753,15 @@ var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunctio
 >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : Promise<number>
 >                                                                                                        : ^^^^^^^^^^^^^^^
 >s3.then(testFunction3P, testFunction3, testFunction3).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                           : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                           : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3.then(testFunction3P, testFunction3, testFunction3) : Promise<IPromise<number>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s3.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s3 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3P : (x: number) => Promise<number>
 >               : ^ ^^      ^^^^^               
 >testFunction3 : (x: number) => IPromise<number>
@@ -769,7 +769,7 @@ var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunctio
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction3 : (x: number) => IPromise<number>
 >              : ^ ^^      ^^^^^                
 >testFunction3 : (x: number) => IPromise<number>
@@ -799,11 +799,11 @@ var r4a = r4.then(testFunction4, testFunction4, testFunction4); // error
 >r4.then(testFunction4, testFunction4, testFunction4) : IPromise<IPromise<string>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r4.then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r4 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >              : ^ ^^      ^^ ^^^      ^^^^^                
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -817,15 +817,15 @@ var r4b = r4.then(sIPromise, testFunction4, testFunction4).then(sIPromise, testF
 >r4.then(sIPromise, testFunction4, testFunction4).then(sIPromise, testFunction4, testFunction4) : IPromise<IPromise<string>>
 >                                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r4.then(sIPromise, testFunction4, testFunction4).then : <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->                                                      : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>                                                      : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r4.then(sIPromise, testFunction4, testFunction4) : IPromise<IPromise<string>>
 >                                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r4.then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r4 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -833,7 +833,7 @@ var r4b = r4.then(sIPromise, testFunction4, testFunction4).then(sIPromise, testF
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >              : ^ ^^      ^^ ^^^      ^^^^^                
 >then : <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -851,11 +851,11 @@ var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 >s4.then(testFunction4, testFunction4, testFunction4) : Promise<string>
 >                                                     : ^^^^^^^^^^^^^^^
 >s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >              : ^ ^^      ^^ ^^^      ^^^^^                
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -869,11 +869,11 @@ var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error
 >s4.then(testFunction4P, testFunction4P, testFunction4P) : Promise<string>
 >                                                        : ^^^^^^^^^^^^^^^
 >s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >               : ^ ^^      ^^ ^^^      ^^^^^               
 >testFunction4P : (x: number, y?: string) => Promise<string>
@@ -887,11 +887,11 @@ var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
 >s4.then(testFunction4P, testFunction4, testFunction4) : Promise<string>
 >                                                      : ^^^^^^^^^^^^^^^
 >s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction4P : (x: number, y?: string) => Promise<string>
 >               : ^ ^^      ^^ ^^^      ^^^^^               
 >testFunction4 : (x: number, y?: string) => IPromise<string>
@@ -905,15 +905,15 @@ var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, test
 >s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4) : Promise<IPromise<string>>
 >                                                                                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s4.then(sIPromise, testFunction4P, testFunction4).then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: IPromise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                       : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                       : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4.then(sIPromise, testFunction4P, testFunction4) : Promise<IPromise<string>>
 >                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s4.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s4 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >testFunction4P : (x: number, y?: string) => Promise<string>
@@ -921,7 +921,7 @@ var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, test
 >testFunction4 : (x: number, y?: string) => IPromise<string>
 >              : ^ ^^      ^^ ^^^      ^^^^^                
 >then : { <TResult1 = IPromise<string>, TResult2 = never>(onfulfilled?: (value: IPromise<string>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >testFunction4P : (x: number, y?: string) => Promise<string>
@@ -939,11 +939,11 @@ var r5a = r5.then(testFunction5, testFunction5, testFunction5); // error
 >r5.then(testFunction5, testFunction5, testFunction5) : IPromise<IPromise<string>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r5.then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r5 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >              : ^ ^^      ^^  ^^                     ^^^^^                
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -957,15 +957,15 @@ var r5b = r5.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >r5.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<IPromise<string>>
 >                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r5.then(sIPromise, sIPromise, sIPromise).then : <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->                                              : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>                                              : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r5.then(sIPromise, sIPromise, sIPromise) : IPromise<IPromise<string>>
 >                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r5.then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r5 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -973,7 +973,7 @@ var r5b = r5.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -991,11 +991,11 @@ var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error
 >s5.then(testFunction5, testFunction5, testFunction5) : Promise<string>
 >                                                     : ^^^^^^^^^^^^^^^
 >s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
 >              : ^ ^^      ^^  ^^                     ^^^^^                
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -1009,11 +1009,11 @@ var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error
 >s5.then(testFunction5P, testFunction5P, testFunction5P) : Promise<string>
 >                                                        : ^^^^^^^^^^^^^^^
 >s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >               : ^ ^^      ^^  ^^                     ^^^^^               
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
@@ -1027,11 +1027,11 @@ var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error
 >s5.then(testFunction5P, testFunction5, testFunction5) : Promise<string>
 >                                                      : ^^^^^^^^^^^^^^^
 >s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction5P : (x: number, cb: (a: string) => string) => Promise<string>
 >               : ^ ^^      ^^  ^^                     ^^^^^               
 >testFunction5 : (x: number, cb: (a: string) => string) => IPromise<string>
@@ -1045,15 +1045,15 @@ var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro
 >s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
 >                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s5.then(sPromise, sPromise, sPromise).then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                           : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                           : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5.then(sPromise, sPromise, sPromise) : Promise<string>
 >                                      : ^^^^^^^^^^^^^^^
 >s5.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s5 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1061,7 +1061,7 @@ var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1079,11 +1079,11 @@ var r6a = r6.then(testFunction6, testFunction6, testFunction6); // error
 >r6.then(testFunction6, testFunction6, testFunction6) : IPromise<IPromise<string>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r6.then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r6 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >              : ^ ^^      ^^  ^^              ^^^^^                
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -1097,15 +1097,15 @@ var r6b = r6.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >r6.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<IPromise<string>>
 >                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r6.then(sIPromise, sIPromise, sIPromise).then : <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->                                              : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>                                              : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r6.then(sIPromise, sIPromise, sIPromise) : IPromise<IPromise<string>>
 >                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r6.then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r6 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1113,7 +1113,7 @@ var r6b = r6.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1131,11 +1131,11 @@ var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error
 >s6.then(testFunction6, testFunction6, testFunction6) : Promise<string>
 >                                                     : ^^^^^^^^^^^^^^^
 >s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
 >              : ^ ^^      ^^  ^^              ^^^^^                
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -1149,11 +1149,11 @@ var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error
 >s6.then(testFunction6P, testFunction6P, testFunction6P) : Promise<string>
 >                                                        : ^^^^^^^^^^^^^^^
 >s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >               : ^ ^^      ^^  ^^              ^^^^^               
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
@@ -1167,11 +1167,11 @@ var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error
 >s6.then(testFunction6P, testFunction6, testFunction6) : Promise<string>
 >                                                      : ^^^^^^^^^^^^^^^
 >s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction6P : (x: number, cb: <T>(a: T) => T) => Promise<string>
 >               : ^ ^^      ^^  ^^              ^^^^^               
 >testFunction6 : (x: number, cb: <T>(a: T) => T) => IPromise<string>
@@ -1185,15 +1185,15 @@ var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro
 >s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
 >                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s6.then(sPromise, sPromise, sPromise).then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                           : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                           : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6.then(sPromise, sPromise, sPromise) : Promise<string>
 >                                      : ^^^^^^^^^^^^^^^
 >s6.then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s6 : Promise<string>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1201,7 +1201,7 @@ var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >then : { <TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1219,11 +1219,11 @@ var r7a = r7.then(testFunction7, testFunction7, testFunction7); // error
 >r7.then(testFunction7, testFunction7, testFunction7) : IPromise<IPromise<string>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r7.then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
 >              : ^  ^^              ^^^^^                
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
@@ -1237,15 +1237,15 @@ var r7b = r7.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >r7.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<IPromise<string>>
 >                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r7.then(sIPromise, sIPromise, sIPromise).then : <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->                                              : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>                                              : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r7.then(sIPromise, sIPromise, sIPromise) : IPromise<IPromise<string>>
 >                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r7.then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1253,7 +1253,7 @@ var r7b = r7.then(sIPromise, sIPromise, sIPromise).then(sIPromise, sIPromise, sI
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : <U>(success?: (value: IPromise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1271,11 +1271,11 @@ var s7a = r7.then(testFunction7, testFunction7, testFunction7); // error
 >r7.then(testFunction7, testFunction7, testFunction7) : IPromise<IPromise<string>>
 >                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r7.then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
 >              : ^  ^^              ^^^^^                
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
@@ -1289,11 +1289,11 @@ var s7b = r7.then(testFunction7P, testFunction7P, testFunction7P); // error
 >r7.then(testFunction7P, testFunction7P, testFunction7P) : IPromise<Promise<string>>
 >                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >r7.then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction7P : (cb: <T>(a: T) => T) => Promise<string>
 >               : ^  ^^              ^^^^^               
 >testFunction7P : (cb: <T>(a: T) => T) => Promise<string>
@@ -1307,11 +1307,11 @@ var s7c = r7.then(testFunction7P, testFunction7, testFunction7); // error
 >r7.then(testFunction7P, testFunction7, testFunction7) : IPromise<IPromise<string>>
 >                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r7.then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction7P : (cb: <T>(a: T) => T) => Promise<string>
 >               : ^  ^^              ^^^^^               
 >testFunction7 : (cb: <T>(a: T) => T) => IPromise<string>
@@ -1325,15 +1325,15 @@ var s7d = r7.then(sPromise, sPromise, sPromise).then(sPromise, sPromise, sPromis
 >r7.then(sPromise, sPromise, sPromise).then(sPromise, sPromise, sPromise) : IPromise<Promise<string>>
 >                                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >r7.then(sPromise, sPromise, sPromise).then : <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->                                           : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>                                           : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r7.then(sPromise, sPromise, sPromise) : IPromise<Promise<string>>
 >                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >r7.then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r7 : IPromise<string>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1341,7 +1341,7 @@ var s7d = r7.then(sPromise, sPromise, sPromise).then(sPromise, sPromise, sPromis
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >then : <U>(success?: (value: Promise<string>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1371,11 +1371,11 @@ var r8a = r8.then(testFunction8, testFunction8, testFunction8); // error
 >r8.then(testFunction8, testFunction8, testFunction8) : IPromise<unknown>
 >                                                     : ^^^^^^^^^^^^^^^^^
 >r8.then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r8 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >              : ^ ^^ ^^ ^^  ^^           ^^^^^           
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -1389,15 +1389,15 @@ var r8b = r8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI
 >r8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : IPromise<IPromise<number>>
 >                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r8.then(nIPromise, nIPromise, nIPromise).then : <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->                                              : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>                                              : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r8.then(nIPromise, nIPromise, nIPromise) : IPromise<IPromise<number>>
 >                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r8.then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r8 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1405,7 +1405,7 @@ var r8b = r8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >then : <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1423,11 +1423,11 @@ var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error
 >s8.then(testFunction8, testFunction8, testFunction8) : Promise<unknown>
 >                                                     : ^^^^^^^^^^^^^^^^
 >s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
 >              : ^ ^^ ^^ ^^  ^^           ^^^^^           
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -1441,11 +1441,11 @@ var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error
 >s8.then(testFunction8P, testFunction8P, testFunction8P) : Promise<unknown>
 >                                                        : ^^^^^^^^^^^^^^^^
 >s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >               : ^ ^^ ^^ ^^  ^^           ^^^^^          
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
@@ -1459,11 +1459,11 @@ var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error
 >s8.then(testFunction8P, testFunction8, testFunction8) : Promise<unknown>
 >                                                      : ^^^^^^^^^^^^^^^^
 >s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction8P : <T>(x: T, cb: (a: T) => T) => Promise<T>
 >               : ^ ^^ ^^ ^^  ^^           ^^^^^          
 >testFunction8 : <T>(x: T, cb: (a: T) => T) => IPromise<T>
@@ -1477,15 +1477,15 @@ var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI
 >s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : Promise<IPromise<number>>
 >                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s8.then(nIPromise, nIPromise, nIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                              : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                              : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8.then(nIPromise, nIPromise, nIPromise) : Promise<IPromise<number>>
 >                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s8.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s8 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1493,7 +1493,7 @@ var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1511,11 +1511,11 @@ var r9a = r9.then(testFunction9, testFunction9, testFunction9); // error
 >r9.then(testFunction9, testFunction9, testFunction9) : IPromise<unknown>
 >                                                     : ^^^^^^^^^^^^^^^^^
 >r9.then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >              : ^ ^^ ^^ ^^  ^^              ^^^^^           
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -1529,11 +1529,11 @@ var r9b = r9.then(sIPromise, sIPromise, sIPromise); // ok
 >r9.then(sIPromise, sIPromise, sIPromise) : IPromise<IPromise<string>>
 >                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r9.then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1547,11 +1547,11 @@ var r9c = r9.then(nIPromise, nIPromise, nIPromise); // ok
 >r9.then(nIPromise, nIPromise, nIPromise) : IPromise<IPromise<number>>
 >                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r9.then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1565,11 +1565,11 @@ var r9d = r9.then(testFunction, sIPromise, nIPromise); // error
 >r9.then(testFunction, sIPromise, nIPromise) : IPromise<IPromise<number>>
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r9.then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1583,15 +1583,15 @@ var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise,
 >r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<IPromise<string>>
 >                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r9.then(testFunction, nIPromise, sIPromise).then : <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->                                                 : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>                                                 : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r9.then(testFunction, nIPromise, sIPromise) : IPromise<IPromise<number>>
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r9.then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>        : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r9 : IPromise<number>
 >   : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1599,7 +1599,7 @@ var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise,
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1617,11 +1617,11 @@ var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
 >s9.then(testFunction9, testFunction9, testFunction9) : Promise<unknown>
 >                                                     : ^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
 >              : ^ ^^ ^^ ^^  ^^              ^^^^^           
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -1635,11 +1635,11 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 >s9.then(testFunction9P, testFunction9P, testFunction9P) : Promise<unknown>
 >                                                        : ^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >               : ^ ^^ ^^ ^^  ^^              ^^^^^          
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
@@ -1653,11 +1653,11 @@ var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 >s9.then(testFunction9P, testFunction9, testFunction9) : Promise<unknown>
 >                                                      : ^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction9P : <T>(x: T, cb: <U>(a: U) => U) => Promise<T>
 >               : ^ ^^ ^^ ^^  ^^              ^^^^^          
 >testFunction9 : <T>(x: T, cb: <U>(a: U) => U) => IPromise<T>
@@ -1671,11 +1671,11 @@ var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 >s9.then(sPromise, sPromise, sPromise) : Promise<string>
 >                                      : ^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1689,11 +1689,11 @@ var s9e = s9.then(nPromise, nPromise, nPromise); // ok
 >s9.then(nPromise, nPromise, nPromise) : Promise<number>
 >                                      : ^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >nPromise : (x: any) => Promise<number>
 >         : ^ ^^   ^^^^^               
 >nPromise : (x: any) => Promise<number>
@@ -1707,11 +1707,11 @@ var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 >s9.then(testFunction, sIPromise, nIPromise) : Promise<number>
 >                                            : ^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1725,15 +1725,15 @@ var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise,
 >s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
 >                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s9.then(testFunction, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                 : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                 : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9.then(testFunction, nIPromise, sIPromise) : Promise<IPromise<number>>
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s9.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>        : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s9 : Promise<number>
 >   : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1741,7 +1741,7 @@ var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise,
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1769,11 +1769,11 @@ var r10a = r10.then(testFunction10, testFunction10, testFunction10); // ok
 >r10.then(testFunction10, testFunction10, testFunction10) : IPromise<IPromise<unknown>>
 >                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r10.then : <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->         : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>         : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >               : ^ ^^  ^^              ^^^^^           
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1787,11 +1787,11 @@ var r10b = r10.then(sIPromise, sIPromise, sIPromise); // ok
 >r10.then(sIPromise, sIPromise, sIPromise) : IPromise<IPromise<string>>
 >                                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r10.then : <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->         : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>         : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1805,11 +1805,11 @@ var r10c = r10.then(nIPromise, nIPromise, nIPromise); // ok
 >r10.then(nIPromise, nIPromise, nIPromise) : IPromise<IPromise<number>>
 >                                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r10.then : <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->         : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>         : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1823,11 +1823,11 @@ var r10d = r10.then(testFunction, sIPromise, nIPromise); // error
 >r10.then(testFunction, sIPromise, nIPromise) : IPromise<IPromise<number>>
 >                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r10.then : <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->         : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>         : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1841,15 +1841,15 @@ var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromis
 >r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : IPromise<IPromise<string>>
 >                                                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r10.then(testFunction, nIPromise, sIPromise).then : <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->                                                  : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>                                                  : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r10.then(testFunction, nIPromise, sIPromise) : IPromise<IPromise<number>>
 >                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r10.then : <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->         : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>         : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r10 : IPromise<unknown>
 >    : ^^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction : () => IPromise<number>
 >             : ^^^^^^                
 >nIPromise : (x: any) => IPromise<number>
@@ -1857,7 +1857,7 @@ var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromis
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >sIPromise : (x: any) => IPromise<string>
@@ -1885,11 +1885,11 @@ var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
 >s10.then(testFunction10, testFunction10, testFunction10) : Promise<IPromise<unknown>>
 >                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
 >               : ^ ^^  ^^              ^^^^^           
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1903,11 +1903,11 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 >s10.then(testFunction10P, testFunction10P, testFunction10P) : Promise<unknown>
 >                                                            : ^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >                : ^ ^^  ^^              ^^^^^          
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
@@ -1921,11 +1921,11 @@ var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 >s10.then(testFunction10P, testFunction10, testFunction10) : Promise<unknown>
 >                                                          : ^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction10P : <T>(cb: <U>(a: U) => U) => Promise<T>
 >                : ^ ^^  ^^              ^^^^^          
 >testFunction10 : <T>(cb: <U>(a: U) => U) => IPromise<T>
@@ -1939,11 +1939,11 @@ var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 >s10.then(sPromise, sPromise, sPromise) : Promise<string>
 >                                       : ^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sPromise : (x: any) => Promise<string>
@@ -1957,11 +1957,11 @@ var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
 >s10.then(nIPromise, nPromise, nIPromise) : Promise<IPromise<number>>
 >                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >nIPromise : (x: any) => IPromise<number>
 >          : ^ ^^   ^^^^^                
 >nPromise : (x: any) => Promise<number>
@@ -1975,11 +1975,11 @@ var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 >s10.then(testFunctionP, sIPromise, nIPromise) : Promise<number>
 >                                              : ^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >sIPromise : (x: any) => IPromise<string>
@@ -1993,15 +1993,15 @@ var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromis
 >s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise) : Promise<IPromise<string>>
 >                                                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then(testFunctionP, nIPromise, sIPromise).then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->                                                   : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>                                                   : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10.then(testFunctionP, nIPromise, sIPromise) : Promise<IPromise<number>>
 >                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >s10.then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s10 : Promise<unknown>
 >    : ^^^^^^^^^^^^^^^^
 >then : { <TResult1 = unknown, TResult2 = never>(onfulfilled?: (value: unknown) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunctionP : () => Promise<number>
 >              : ^^^^^^               
 >nIPromise : (x: any) => IPromise<number>
@@ -2009,7 +2009,7 @@ var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromis
 >sIPromise : (x: any) => IPromise<string>
 >          : ^ ^^   ^^^^^                
 >then : { <TResult1 = IPromise<number>, TResult2 = never>(onfulfilled?: (value: IPromise<number>) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: IPromise<number>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >sPromise : (x: any) => Promise<string>
 >         : ^ ^^   ^^^^^               
 >sIPromise : (x: any) => IPromise<string>
@@ -2027,11 +2027,11 @@ var r11a = r11.then(testFunction11, testFunction11, testFunction11); // ok
 >r11.then(testFunction11, testFunction11, testFunction11) : IPromise<IPromise<string>>
 >                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r11.then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->         : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>         : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r11 : IPromise<number>
 >    : ^^^^^^^^^^^^^^^^
 >then : <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >               : ^^^ ^^      ^^^                ^^^ ^^      ^^^                ^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
@@ -2049,11 +2049,11 @@ var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
 >s11.then(testFunction11, testFunction11, testFunction11) : Promise<string>
 >                                                         : ^^^^^^^^^^^^^^^
 >s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s11 : Promise<number>
 >    : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
 >               : ^^^ ^^      ^^^                ^^^ ^^      ^^^                ^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
@@ -2067,11 +2067,11 @@ var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
 >s11.then(testFunction11P, testFunction11P, testFunction11P) : Promise<string>
 >                                                            : ^^^^^^^^^^^^^^^
 >s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s11 : Promise<number>
 >    : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >                : ^^^ ^^      ^^^               ^^^ ^^      ^^^               ^^^
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
@@ -2085,11 +2085,11 @@ var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
 >s11.then(testFunction11P, testFunction11, testFunction11) : Promise<string>
 >                                                          : ^^^^^^^^^^^^^^^
 >s11.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>         : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >s11 : Promise<number>
 >    : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^        ^ ^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^^^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^^        ^^   ^^^^^    ^^^^^^^^^^^^^^^^
 >testFunction11P : { (x: number): Promise<number>; (x: string): Promise<string>; }
 >                : ^^^ ^^      ^^^               ^^^ ^^      ^^^               ^^^
 >testFunction11 : { (x: number): IPromise<number>; (x: string): IPromise<string>; }
@@ -2117,11 +2117,11 @@ var r12a = r12.then(testFunction12, testFunction12, testFunction12); // ok
 >r12.then(testFunction12, testFunction12, testFunction12) : IPromise<IPromise<unknown>>
 >                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >r12.then : <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->         : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>         : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >r12 : IPromise<(x: any) => any>
 >    : ^^^^^^^^^^ ^^^^^^^^^^^^^^
 >then : <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
 >               : ^^^ ^^ ^^ ^^^           ^^^ ^^ ^^ ^^ ^^ ^^^           ^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
@@ -2149,11 +2149,11 @@ var s12a = s12.then(testFunction12, testFunction12, testFunction12); // ok
 >s12.then(testFunction12, testFunction12, testFunction12) : IPromise<IPromise<unknown>>
 >                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s12.then : <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->         : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>         : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >s12 : IPromise<(x: any) => any>
 >    : ^^^^^^^^^^ ^^^^^^^^^^^^^^
 >then : <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
 >               : ^^^ ^^ ^^ ^^^           ^^^ ^^ ^^ ^^ ^^ ^^^           ^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
@@ -2167,11 +2167,11 @@ var s12b = s12.then(testFunction12P, testFunction12P, testFunction12P); // ok
 >s12.then(testFunction12P, testFunction12P, testFunction12P) : IPromise<Promise<unknown>>
 >                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s12.then : <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->         : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>         : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >s12 : IPromise<(x: any) => any>
 >    : ^^^^^^^^^^ ^^^^^^^^^^^^^^
 >then : <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction12P : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }
 >                : ^^^ ^^ ^^ ^^^           ^^^ ^^ ^^ ^^ ^^ ^^^          ^^^
 >testFunction12P : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }
@@ -2185,11 +2185,11 @@ var s12c = s12.then(testFunction12P, testFunction12, testFunction12); // ok
 >s12.then(testFunction12P, testFunction12, testFunction12) : IPromise<IPromise<unknown>>
 >                                                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s12.then : <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->         : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>         : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >s12 : IPromise<(x: any) => any>
 >    : ^^^^^^^^^^ ^^^^^^^^^^^^^^
 >then : <U>(success?: (value: (x: any) => any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>
->     : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^ ^^^^^^^^^^^^^^^^^^^^^     ^^^^     ^^   ^^^^^^^^        ^^^                       ^^^^^^^^^^^^^^^^
 >testFunction12P : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }
 >                : ^^^ ^^ ^^ ^^^           ^^^ ^^ ^^ ^^ ^^ ^^^          ^^^
 >testFunction12 : { <T>(x: T): IPromise<T>; <T>(x: T, y: T): IPromise<T>; }
diff --git a/tests/baselines/reference/promiseTest.types b/tests/baselines/reference/promiseTest.types
index 3149494c07519..9c341375dfe84 100644
--- a/tests/baselines/reference/promiseTest.types
+++ b/tests/baselines/reference/promiseTest.types
@@ -33,11 +33,11 @@ var p2 = p.then(function (x) {
 >p.then(function (x) {    return p;} ) : Promise<number>
 >                                      : ^^^^^^^^^^^^^^^
 >p.then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
->       : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^        ^ ^^^
+>       : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<number>
 >  : ^^^^^^^^^^^^^^^
 >then : { <TResult1 = number, TResult2 = never>(onfulfilled?: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
->     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^        ^^^^^^^^   ^^^^^^^^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^        ^ ^^^        ^ ^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^        ^ ^^^
+>     : ^^^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >function (x) {    return p;} : (x: number) => Promise<number>
 >                             : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
diff --git a/tests/baselines/reference/promiseType.types b/tests/baselines/reference/promiseType.types
index 2d2911e7d1bd6..1a975630f0f52 100644
--- a/tests/baselines/reference/promiseType.types
+++ b/tests/baselines/reference/promiseType.types
@@ -1,7 +1,7 @@
 //// [tests/cases/compiler/promiseType.ts] ////
 
 === Performance Stats ===
-Instantiation count: 2,500 -> 10,000
+Instantiation count: 2,500 -> 5,000
 
 === promiseType.ts ===
 declare var p: Promise<boolean>;
@@ -253,11 +253,11 @@ const p00 = p.catch();
 >p.catch() : Promise<boolean>
 >          : ^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const p01 = p.then();
 >p01 : Promise<boolean>
@@ -265,11 +265,11 @@ const p01 = p.then();
 >p.then() : Promise<boolean>
 >         : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const p10 = p.catch(undefined);
 >p10 : Promise<boolean>
@@ -277,11 +277,11 @@ const p10 = p.catch(undefined);
 >p.catch(undefined) : Promise<boolean>
 >                   : ^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 
@@ -291,11 +291,11 @@ const p11 = p.catch(null);
 >p.catch(null) : Promise<boolean>
 >              : ^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const p12 = p.catch(() => 1);
 >p12 : Promise<number | boolean>
@@ -303,11 +303,11 @@ const p12 = p.catch(() => 1);
 >p.catch(() => 1) : Promise<number | boolean>
 >                 : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
 >1 : 1
@@ -319,11 +319,11 @@ const p13 = p.catch(() => x);
 >p.catch(() => x) : Promise<any>
 >                 : ^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -334,11 +334,11 @@ const p14 = p.catch(() => undefined);
 >p.catch(() => undefined) : Promise<any>
 >                         : ^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => any
 >                : ^^^^^^^^^
 >undefined : undefined
@@ -350,11 +350,11 @@ const p15 = p.catch(() => null);
 >p.catch(() => null) : Promise<any>
 >                    : ^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => any
 >           : ^^^^^^^^^
 
@@ -364,11 +364,11 @@ const p16 = p.catch(() => {});
 >p.catch(() => {}) : Promise<boolean | void>
 >                  : ^^^^^^^^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 
@@ -378,11 +378,11 @@ const p17 = p.catch(() => {throw 1});
 >p.catch(() => {throw 1}) : Promise<boolean>
 >                         : ^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -394,11 +394,11 @@ const p18 = p.catch(() => Promise.reject(1));
 >p.catch(() => Promise.reject(1)) : Promise<boolean>
 >                                 : ^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject(1) : () => Promise<never>
 >                        : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject(1) : Promise<never>
@@ -418,11 +418,11 @@ const p19 = p.catch(() => Promise.resolve(1));
 >p.catch(() => Promise.resolve(1)) : Promise<number | boolean>
 >                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve(1) : () => Promise<number>
 >                         : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve(1) : Promise<number>
@@ -442,11 +442,11 @@ const p20 = p.then(undefined);
 >p.then(undefined) : Promise<boolean>
 >                  : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 
@@ -456,11 +456,11 @@ const p21 = p.then(null);
 >p.then(null) : Promise<boolean>
 >             : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const p22 = p.then(() => 1);
 >p22 : Promise<number>
@@ -468,11 +468,11 @@ const p22 = p.then(() => 1);
 >p.then(() => 1) : Promise<number>
 >                : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
 >1 : 1
@@ -484,11 +484,11 @@ const p23 = p.then(() => x);
 >p.then(() => x) : Promise<any>
 >                : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -499,11 +499,11 @@ const p24 = p.then(() => undefined);
 >p.then(() => undefined) : Promise<any>
 >                        : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => any
 >                : ^^^^^^^^^
 >undefined : undefined
@@ -515,11 +515,11 @@ const p25 = p.then(() => null);
 >p.then(() => null) : Promise<any>
 >                   : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => any
 >           : ^^^^^^^^^
 
@@ -529,11 +529,11 @@ const p26 = p.then(() => {});
 >p.then(() => {}) : Promise<void>
 >                 : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 
@@ -543,11 +543,11 @@ const p27 = p.then(() => {throw 1});
 >p.then(() => {throw 1}) : Promise<never>
 >                        : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -559,11 +559,11 @@ const p28 = p.then(() => Promise.resolve(1));
 >p.then(() => Promise.resolve(1)) : Promise<number>
 >                                 : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve(1) : () => Promise<number>
 >                         : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve(1) : Promise<number>
@@ -583,11 +583,11 @@ const p29 = p.then(() => Promise.reject(1));
 >p.then(() => Promise.reject(1)) : Promise<never>
 >                                : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject(1) : () => Promise<never>
 >                        : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject(1) : Promise<never>
@@ -607,11 +607,11 @@ const p30 = p.then(undefined, undefined);
 >p.then(undefined, undefined) : Promise<boolean>
 >                             : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >undefined : undefined
@@ -623,11 +623,11 @@ const p31 = p.then(undefined, null);
 >p.then(undefined, null) : Promise<boolean>
 >                        : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 
@@ -637,11 +637,11 @@ const p32 = p.then(undefined, () => 1);
 >p.then(undefined, () => 1) : Promise<number | boolean>
 >                           : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => 1 : () => number
@@ -655,11 +655,11 @@ const p33 = p.then(undefined, () => x);
 >p.then(undefined, () => x) : Promise<any>
 >                           : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => x : () => any
@@ -672,11 +672,11 @@ const p34 = p.then(undefined, () => undefined);
 >p.then(undefined, () => undefined) : Promise<any>
 >                                   : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => undefined : () => any
@@ -690,11 +690,11 @@ const p35 = p.then(undefined, () => null);
 >p.then(undefined, () => null) : Promise<any>
 >                              : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => null : () => any
@@ -706,11 +706,11 @@ const p36 = p.then(undefined, () => {});
 >p.then(undefined, () => {}) : Promise<boolean | void>
 >                            : ^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => {} : () => void
@@ -722,11 +722,11 @@ const p37 = p.then(undefined, () => {throw 1});
 >p.then(undefined, () => {throw 1}) : Promise<boolean>
 >                                   : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => {throw 1} : () => never
@@ -740,11 +740,11 @@ const p38 = p.then(undefined, () => Promise.resolve(1));
 >p.then(undefined, () => Promise.resolve(1)) : Promise<number | boolean>
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => Promise.resolve(1) : () => Promise<number>
@@ -766,11 +766,11 @@ const p39 = p.then(undefined, () => Promise.reject(1));
 >p.then(undefined, () => Promise.reject(1)) : Promise<boolean>
 >                                           : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => Promise.reject(1) : () => Promise<never>
@@ -792,11 +792,11 @@ const p40 = p.then(null, undefined);
 >p.then(null, undefined) : Promise<boolean>
 >                        : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 
@@ -806,11 +806,11 @@ const p41 = p.then(null, null);
 >p.then(null, null) : Promise<boolean>
 >                   : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const p42 = p.then(null, () => 1);
 >p42 : Promise<number | boolean>
@@ -818,11 +818,11 @@ const p42 = p.then(null, () => 1);
 >p.then(null, () => 1) : Promise<number | boolean>
 >                      : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
 >1 : 1
@@ -834,11 +834,11 @@ const p43 = p.then(null, () => x);
 >p.then(null, () => x) : Promise<any>
 >                      : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -849,11 +849,11 @@ const p44 = p.then(null, () => undefined);
 >p.then(null, () => undefined) : Promise<any>
 >                              : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => any
 >                : ^^^^^^^^^
 >undefined : undefined
@@ -865,11 +865,11 @@ const p45 = p.then(null, () => null);
 >p.then(null, () => null) : Promise<any>
 >                         : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => any
 >           : ^^^^^^^^^
 
@@ -879,11 +879,11 @@ const p46 = p.then(null, () => {});
 >p.then(null, () => {}) : Promise<boolean | void>
 >                       : ^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 
@@ -893,11 +893,11 @@ const p47 = p.then(null, () => {throw 1});
 >p.then(null, () => {throw 1}) : Promise<boolean>
 >                              : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -909,11 +909,11 @@ const p48 = p.then(null, () => Promise.resolve(1));
 >p.then(null, () => Promise.resolve(1)) : Promise<number | boolean>
 >                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve(1) : () => Promise<number>
 >                         : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve(1) : Promise<number>
@@ -933,11 +933,11 @@ const p49 = p.then(null, () => Promise.reject(1));
 >p.then(null, () => Promise.reject(1)) : Promise<boolean>
 >                                      : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject(1) : () => Promise<never>
 >                        : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject(1) : Promise<never>
@@ -957,11 +957,11 @@ const p50 = p.then(() => "1", undefined);
 >p.then(() => "1", undefined) : Promise<string>
 >                             : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -975,11 +975,11 @@ const p51 = p.then(() => "1", null);
 >p.then(() => "1", null) : Promise<string>
 >                        : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -991,11 +991,11 @@ const p52 = p.then(() => "1", () => 1);
 >p.then(() => "1", () => 1) : Promise<string | number>
 >                           : ^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1011,11 +1011,11 @@ const p53 = p.then(() => "1", () => x);
 >p.then(() => "1", () => x) : Promise<any>
 >                           : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1030,11 +1030,11 @@ const p54 = p.then(() => "1", () => undefined);
 >p.then(() => "1", () => undefined) : Promise<any>
 >                                   : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1050,11 +1050,11 @@ const p55 = p.then(() => "1", () => null);
 >p.then(() => "1", () => null) : Promise<any>
 >                              : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1068,11 +1068,11 @@ const p56 = p.then(() => "1", () => {});
 >p.then(() => "1", () => {}) : Promise<string | void>
 >                            : ^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1086,11 +1086,11 @@ const p57 = p.then(() => "1", () => {throw 1});
 >p.then(() => "1", () => {throw 1}) : Promise<string>
 >                                   : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1106,11 +1106,11 @@ const p58 = p.then(() => "1", () => Promise.resolve(1));
 >p.then(() => "1", () => Promise.resolve(1)) : Promise<string | number>
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1134,11 +1134,11 @@ const p59 = p.then(() => "1", () => Promise.reject(1));
 >p.then(() => "1", () => Promise.reject(1)) : Promise<string>
 >                                           : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1162,11 +1162,11 @@ const p60 = p.then(() => x, undefined);
 >p.then(() => x, undefined) : Promise<any>
 >                           : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1179,11 +1179,11 @@ const p61 = p.then(() => x, null);
 >p.then(() => x, null) : Promise<any>
 >                      : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1194,11 +1194,11 @@ const p62 = p.then(() => x, () => 1);
 >p.then(() => x, () => 1) : Promise<any>
 >                         : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1213,11 +1213,11 @@ const p63 = p.then(() => x, () => x);
 >p.then(() => x, () => x) : Promise<any>
 >                         : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1231,11 +1231,11 @@ const p64 = p.then(() => x, () => undefined);
 >p.then(() => x, () => undefined) : Promise<any>
 >                                 : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1250,11 +1250,11 @@ const p65 = p.then(() => x, () => null);
 >p.then(() => x, () => null) : Promise<any>
 >                            : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1267,11 +1267,11 @@ const p66 = p.then(() => x, () => {});
 >p.then(() => x, () => {}) : Promise<any>
 >                          : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1284,11 +1284,11 @@ const p67 = p.then(() => x, () => {throw 1});
 >p.then(() => x, () => {throw 1}) : Promise<any>
 >                                 : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1303,11 +1303,11 @@ const p68 = p.then(() => x, () => Promise.resolve(1));
 >p.then(() => x, () => Promise.resolve(1)) : Promise<any>
 >                                          : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1330,11 +1330,11 @@ const p69 = p.then(() => x, () => Promise.reject(1));
 >p.then(() => x, () => Promise.reject(1)) : Promise<any>
 >                                         : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1357,11 +1357,11 @@ const p70 = p.then(() => undefined, undefined);
 >p.then(() => undefined, undefined) : Promise<any>
 >                                   : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => any
 >                : ^^^^^^^^^
 >undefined : undefined
@@ -1375,11 +1375,11 @@ const p71 = p.then(() => undefined, null);
 >p.then(() => undefined, null) : Promise<any>
 >                              : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => any
 >                : ^^^^^^^^^
 >undefined : undefined
@@ -1391,11 +1391,11 @@ const p72 = p.then(() => undefined, () => 1);
 >p.then(() => undefined, () => 1) : Promise<any>
 >                                 : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => any
 >                : ^^^^^^^^^
 >undefined : undefined
@@ -1411,11 +1411,11 @@ const p73 = p.then(() => undefined, () => x);
 >p.then(() => undefined, () => x) : Promise<any>
 >                                 : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => any
 >                : ^^^^^^^^^
 >undefined : undefined
@@ -1430,11 +1430,11 @@ const p74 = p.then(() => undefined, () => undefined);
 >p.then(() => undefined, () => undefined) : Promise<any>
 >                                         : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => any
 >                : ^^^^^^^^^
 >undefined : undefined
@@ -1450,11 +1450,11 @@ const p75 = p.then(() => undefined, () => null);
 >p.then(() => undefined, () => null) : Promise<any>
 >                                    : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => any
 >                : ^^^^^^^^^
 >undefined : undefined
@@ -1468,11 +1468,11 @@ const p76 = p.then(() => undefined, () => {});
 >p.then(() => undefined, () => {}) : Promise<any>
 >                                  : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => any
 >                : ^^^^^^^^^
 >undefined : undefined
@@ -1486,11 +1486,11 @@ const p77 = p.then(() => undefined, () => {throw 1});
 >p.then(() => undefined, () => {throw 1}) : Promise<any>
 >                                         : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => any
 >                : ^^^^^^^^^
 >undefined : undefined
@@ -1506,11 +1506,11 @@ const p78 = p.then(() => undefined, () => Promise.resolve(1));
 >p.then(() => undefined, () => Promise.resolve(1)) : Promise<any>
 >                                                  : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => any
 >                : ^^^^^^^^^
 >undefined : undefined
@@ -1534,11 +1534,11 @@ const p79 = p.then(() => undefined, () => Promise.reject(1));
 >p.then(() => undefined, () => Promise.reject(1)) : Promise<any>
 >                                                 : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => any
 >                : ^^^^^^^^^
 >undefined : undefined
@@ -1562,11 +1562,11 @@ const p80 = p.then(() => null, undefined);
 >p.then(() => null, undefined) : Promise<any>
 >                              : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => any
 >           : ^^^^^^^^^
 >undefined : undefined
@@ -1578,11 +1578,11 @@ const p81 = p.then(() => null, null);
 >p.then(() => null, null) : Promise<any>
 >                         : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => any
 >           : ^^^^^^^^^
 
@@ -1592,11 +1592,11 @@ const p82 = p.then(() => null, () => 1);
 >p.then(() => null, () => 1) : Promise<any>
 >                            : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => any
 >           : ^^^^^^^^^
 >() => 1 : () => number
@@ -1610,11 +1610,11 @@ const p83 = p.then(() => null, () => x);
 >p.then(() => null, () => x) : Promise<any>
 >                            : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => any
 >           : ^^^^^^^^^
 >() => x : () => any
@@ -1627,11 +1627,11 @@ const p84 = p.then(() => null, () => undefined);
 >p.then(() => null, () => undefined) : Promise<any>
 >                                    : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => any
 >           : ^^^^^^^^^
 >() => undefined : () => any
@@ -1645,11 +1645,11 @@ const p85 = p.then(() => null, () => null);
 >p.then(() => null, () => null) : Promise<any>
 >                               : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => any
 >           : ^^^^^^^^^
 >() => null : () => any
@@ -1661,11 +1661,11 @@ const p86 = p.then(() => null, () => {});
 >p.then(() => null, () => {}) : Promise<any>
 >                             : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => any
 >           : ^^^^^^^^^
 >() => {} : () => void
@@ -1677,11 +1677,11 @@ const p87 = p.then(() => null, () => {throw 1});
 >p.then(() => null, () => {throw 1}) : Promise<any>
 >                                    : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => any
 >           : ^^^^^^^^^
 >() => {throw 1} : () => never
@@ -1695,11 +1695,11 @@ const p88 = p.then(() => null, () => Promise.resolve(1));
 >p.then(() => null, () => Promise.resolve(1)) : Promise<any>
 >                                             : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => any
 >           : ^^^^^^^^^
 >() => Promise.resolve(1) : () => Promise<number>
@@ -1721,11 +1721,11 @@ const p89 = p.then(() => null, () => Promise.reject(1));
 >p.then(() => null, () => Promise.reject(1)) : Promise<any>
 >                                            : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => any
 >           : ^^^^^^^^^
 >() => Promise.reject(1) : () => Promise<never>
@@ -1747,11 +1747,11 @@ const p90 = p.then(() => {}, undefined);
 >p.then(() => {}, undefined) : Promise<void>
 >                            : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >undefined : undefined
@@ -1763,11 +1763,11 @@ const p91 = p.then(() => {}, null);
 >p.then(() => {}, null) : Promise<void>
 >                       : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 
@@ -1777,11 +1777,11 @@ const p92 = p.then(() => {}, () => 1);
 >p.then(() => {}, () => 1) : Promise<number | void>
 >                          : ^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => 1 : () => number
@@ -1795,11 +1795,11 @@ const p93 = p.then(() => {}, () => x);
 >p.then(() => {}, () => x) : Promise<any>
 >                          : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => x : () => any
@@ -1812,11 +1812,11 @@ const p94 = p.then(() => {}, () => undefined);
 >p.then(() => {}, () => undefined) : Promise<any>
 >                                  : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => undefined : () => any
@@ -1830,11 +1830,11 @@ const p95 = p.then(() => {}, () => null);
 >p.then(() => {}, () => null) : Promise<any>
 >                             : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => null : () => any
@@ -1846,11 +1846,11 @@ const p96 = p.then(() => {}, () => {});
 >p.then(() => {}, () => {}) : Promise<void>
 >                           : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => {} : () => void
@@ -1862,11 +1862,11 @@ const p97 = p.then(() => {}, () => {throw 1});
 >p.then(() => {}, () => {throw 1}) : Promise<void>
 >                                  : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => {throw 1} : () => never
@@ -1880,11 +1880,11 @@ const p98 = p.then(() => {}, () => Promise.resolve(1));
 >p.then(() => {}, () => Promise.resolve(1)) : Promise<number | void>
 >                                           : ^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => Promise.resolve(1) : () => Promise<number>
@@ -1906,11 +1906,11 @@ const p99 = p.then(() => {}, () => Promise.reject(1));
 >p.then(() => {}, () => Promise.reject(1)) : Promise<void>
 >                                          : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => Promise.reject(1) : () => Promise<never>
@@ -1932,11 +1932,11 @@ const pa0 = p.then(() => {throw 1}, undefined);
 >p.then(() => {throw 1}, undefined) : Promise<never>
 >                                   : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -1950,11 +1950,11 @@ const pa1 = p.then(() => {throw 1}, null);
 >p.then(() => {throw 1}, null) : Promise<never>
 >                              : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -1966,11 +1966,11 @@ const pa2 = p.then(() => {throw 1}, () => 1);
 >p.then(() => {throw 1}, () => 1) : Promise<number>
 >                                 : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -1986,11 +1986,11 @@ const pa3 = p.then(() => {throw 1}, () => x);
 >p.then(() => {throw 1}, () => x) : Promise<any>
 >                                 : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2005,11 +2005,11 @@ const pa4 = p.then(() => {throw 1}, () => undefined);
 >p.then(() => {throw 1}, () => undefined) : Promise<any>
 >                                         : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2025,11 +2025,11 @@ const pa5 = p.then(() => {throw 1}, () => null);
 >p.then(() => {throw 1}, () => null) : Promise<any>
 >                                    : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2043,11 +2043,11 @@ const pa6 = p.then(() => {throw 1}, () => {});
 >p.then(() => {throw 1}, () => {}) : Promise<void>
 >                                  : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2061,11 +2061,11 @@ const pa7 = p.then(() => {throw 1}, () => {throw 1});
 >p.then(() => {throw 1}, () => {throw 1}) : Promise<never>
 >                                         : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2081,11 +2081,11 @@ const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >p.then(() => {throw 1}, () => Promise.resolve(1)) : Promise<number>
 >                                                  : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2109,11 +2109,11 @@ const pa9 = p.then(() => {throw 1}, () => Promise.reject(1));
 >p.then(() => {throw 1}, () => Promise.reject(1)) : Promise<never>
 >                                                 : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2137,11 +2137,11 @@ const pb0 = p.then(() => Promise.resolve("1"), undefined);
 >p.then(() => Promise.resolve("1"), undefined) : Promise<string>
 >                                              : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2163,11 +2163,11 @@ const pb1 = p.then(() => Promise.resolve("1"), null);
 >p.then(() => Promise.resolve("1"), null) : Promise<string>
 >                                         : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2187,11 +2187,11 @@ const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 >p.then(() => Promise.resolve("1"), () => 1) : Promise<string | number>
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2215,11 +2215,11 @@ const pb3 = p.then(() => Promise.resolve("1"), () => x);
 >p.then(() => Promise.resolve("1"), () => x) : Promise<any>
 >                                            : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2242,11 +2242,11 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 >p.then(() => Promise.resolve("1"), () => undefined) : Promise<any>
 >                                                    : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2270,11 +2270,11 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null);
 >p.then(() => Promise.resolve("1"), () => null) : Promise<any>
 >                                               : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2296,11 +2296,11 @@ const pb6 = p.then(() => Promise.resolve("1"), () => {});
 >p.then(() => Promise.resolve("1"), () => {}) : Promise<string | void>
 >                                             : ^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2322,11 +2322,11 @@ const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >p.then(() => Promise.resolve("1"), () => {throw 1}) : Promise<string>
 >                                                    : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2350,11 +2350,11 @@ const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >p.then(() => Promise.resolve("1"), () => Promise.resolve(1)) : Promise<string | number>
 >                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2386,11 +2386,11 @@ const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >p.then(() => Promise.resolve("1"), () => Promise.reject(1)) : Promise<string>
 >                                                            : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2422,11 +2422,11 @@ const pc0 = p.then(() => Promise.reject("1"), undefined);
 >p.then(() => Promise.reject("1"), undefined) : Promise<never>
 >                                             : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2448,11 +2448,11 @@ const pc1 = p.then(() => Promise.reject("1"), null);
 >p.then(() => Promise.reject("1"), null) : Promise<never>
 >                                        : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2472,11 +2472,11 @@ const pc2 = p.then(() => Promise.reject("1"), () => 1);
 >p.then(() => Promise.reject("1"), () => 1) : Promise<number>
 >                                           : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2500,11 +2500,11 @@ const pc3 = p.then(() => Promise.reject("1"), () => x);
 >p.then(() => Promise.reject("1"), () => x) : Promise<any>
 >                                           : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2527,11 +2527,11 @@ const pc4 = p.then(() => Promise.reject("1"), () => undefined);
 >p.then(() => Promise.reject("1"), () => undefined) : Promise<any>
 >                                                   : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2555,11 +2555,11 @@ const pc5 = p.then(() => Promise.reject("1"), () => null);
 >p.then(() => Promise.reject("1"), () => null) : Promise<any>
 >                                              : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2581,11 +2581,11 @@ const pc6 = p.then(() => Promise.reject("1"), () => {});
 >p.then(() => Promise.reject("1"), () => {}) : Promise<void>
 >                                            : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2607,11 +2607,11 @@ const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 >p.then(() => Promise.reject("1"), () => {throw 1}) : Promise<never>
 >                                                   : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2635,11 +2635,11 @@ const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 >p.then(() => Promise.reject("1"), () => Promise.resolve(1)) : Promise<number>
 >                                                            : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2671,11 +2671,11 @@ const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
 >p.then(() => Promise.reject("1"), () => Promise.reject(1)) : Promise<never>
 >                                                           : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: (value: boolean) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
diff --git a/tests/baselines/reference/promiseTypeInference.types b/tests/baselines/reference/promiseTypeInference.types
index d16e91f147aa5..5b06d5560f208 100644
--- a/tests/baselines/reference/promiseTypeInference.types
+++ b/tests/baselines/reference/promiseTypeInference.types
@@ -40,7 +40,7 @@ var $$x = load("something").then(s => convert(s));
 >load("something").then(s => convert(s)) : CPromise<number>
 >                                        : ^^^^^^^^^^^^^^^^
 >load("something").then : <U>(success?: (value: string) => CPromise<U>) => CPromise<U>
->                       : ^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^^^^         ^ 
+>                       : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >load("something") : CPromise<string>
 >                  : ^^^^^^^^^^^^^^^^
 >load : (name: string) => CPromise<string>
@@ -48,7 +48,7 @@ var $$x = load("something").then(s => convert(s));
 >"something" : "something"
 >            : ^^^^^^^^^^^
 >then : <U>(success?: (value: string) => CPromise<U>) => CPromise<U>
->     : ^ ^^       ^^^^     ^^^^^^^^^^^^^         ^ ^^^^^         ^ 
+>     : ^ ^^       ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s => convert(s) : (s: string) => IPromise<number>
 >                : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >s : string
diff --git a/tests/baselines/reference/promiseTypeStrictNull.types b/tests/baselines/reference/promiseTypeStrictNull.types
index beae1e4e94cce..7ff8d96c59faa 100644
--- a/tests/baselines/reference/promiseTypeStrictNull.types
+++ b/tests/baselines/reference/promiseTypeStrictNull.types
@@ -1,7 +1,7 @@
 //// [tests/cases/compiler/promiseTypeStrictNull.ts] ////
 
 === Performance Stats ===
-Instantiation count: 2,500 -> 10,000
+Instantiation count: 2,500 -> 5,000
 
 === promiseTypeStrictNull.ts ===
 declare var p: Promise<boolean>;
@@ -253,11 +253,11 @@ const p00 = p.catch();
 >p.catch() : Promise<boolean>
 >          : ^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const p01 = p.then();
 >p01 : Promise<boolean>
@@ -265,11 +265,11 @@ const p01 = p.then();
 >p.then() : Promise<boolean>
 >         : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const p10 = p.catch(undefined);
 >p10 : Promise<boolean>
@@ -277,11 +277,11 @@ const p10 = p.catch(undefined);
 >p.catch(undefined) : Promise<boolean>
 >                   : ^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 
@@ -291,11 +291,11 @@ const p11 = p.catch(null);
 >p.catch(null) : Promise<boolean>
 >              : ^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const p12 = p.catch(() => 1);
 >p12 : Promise<number | boolean>
@@ -303,11 +303,11 @@ const p12 = p.catch(() => 1);
 >p.catch(() => 1) : Promise<number | boolean>
 >                 : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
 >1 : 1
@@ -319,11 +319,11 @@ const p13 = p.catch(() => x);
 >p.catch(() => x) : Promise<any>
 >                 : ^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -334,11 +334,11 @@ const p14 = p.catch(() => undefined);
 >p.catch(() => undefined) : Promise<boolean | undefined>
 >                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => undefined
 >                : ^^^^^^^^^^^^^^^
 >undefined : undefined
@@ -350,11 +350,11 @@ const p15 = p.catch(() => null);
 >p.catch(() => null) : Promise<boolean | null>
 >                    : ^^^^^^^^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => null
 >           : ^^^^^^^^^^
 
@@ -364,11 +364,11 @@ const p16 = p.catch(() => {});
 >p.catch(() => {}) : Promise<boolean | void>
 >                  : ^^^^^^^^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 
@@ -378,11 +378,11 @@ const p17 = p.catch(() => {throw 1});
 >p.catch(() => {throw 1}) : Promise<boolean>
 >                         : ^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -394,11 +394,11 @@ const p18 = p.catch(() => Promise.reject(1));
 >p.catch(() => Promise.reject(1)) : Promise<boolean>
 >                                 : ^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject(1) : () => Promise<never>
 >                        : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject(1) : Promise<never>
@@ -418,11 +418,11 @@ const p19 = p.catch(() => Promise.resolve(1));
 >p.catch(() => Promise.resolve(1)) : Promise<number | boolean>
 >                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>        : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >catch : <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<boolean | TResult>
->      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^               ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^   ^^^^^^^ 
+>      : ^       ^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve(1) : () => Promise<number>
 >                         : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve(1) : Promise<number>
@@ -442,11 +442,11 @@ const p20 = p.then(undefined);
 >p.then(undefined) : Promise<boolean>
 >                  : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 
@@ -456,11 +456,11 @@ const p21 = p.then(null);
 >p.then(null) : Promise<boolean>
 >             : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const p22 = p.then(() => 1);
 >p22 : Promise<number>
@@ -468,11 +468,11 @@ const p22 = p.then(() => 1);
 >p.then(() => 1) : Promise<number>
 >                : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
 >1 : 1
@@ -484,11 +484,11 @@ const p23 = p.then(() => x);
 >p.then(() => x) : Promise<any>
 >                : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -499,11 +499,11 @@ const p24 = p.then(() => undefined);
 >p.then(() => undefined) : Promise<undefined>
 >                        : ^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => undefined
 >                : ^^^^^^^^^^^^^^^
 >undefined : undefined
@@ -515,11 +515,11 @@ const p25 = p.then(() => null);
 >p.then(() => null) : Promise<null>
 >                   : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => null
 >           : ^^^^^^^^^^
 
@@ -529,11 +529,11 @@ const p26 = p.then(() => {});
 >p.then(() => {}) : Promise<void>
 >                 : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 
@@ -543,11 +543,11 @@ const p27 = p.then(() => {throw 1});
 >p.then(() => {throw 1}) : Promise<never>
 >                        : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -559,11 +559,11 @@ const p28 = p.then(() => Promise.resolve(1));
 >p.then(() => Promise.resolve(1)) : Promise<number>
 >                                 : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve(1) : () => Promise<number>
 >                         : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve(1) : Promise<number>
@@ -583,11 +583,11 @@ const p29 = p.then(() => Promise.reject(1));
 >p.then(() => Promise.reject(1)) : Promise<never>
 >                                : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject(1) : () => Promise<never>
 >                        : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject(1) : Promise<never>
@@ -607,11 +607,11 @@ const p30 = p.then(undefined, undefined);
 >p.then(undefined, undefined) : Promise<boolean>
 >                             : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >undefined : undefined
@@ -623,11 +623,11 @@ const p31 = p.then(undefined, null);
 >p.then(undefined, null) : Promise<boolean>
 >                        : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 
@@ -637,11 +637,11 @@ const p32 = p.then(undefined, () => 1);
 >p.then(undefined, () => 1) : Promise<number | boolean>
 >                           : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => 1 : () => number
@@ -655,11 +655,11 @@ const p33 = p.then(undefined, () => x);
 >p.then(undefined, () => x) : Promise<any>
 >                           : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => x : () => any
@@ -672,11 +672,11 @@ const p34 = p.then(undefined, () => undefined);
 >p.then(undefined, () => undefined) : Promise<boolean | undefined>
 >                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => undefined : () => undefined
@@ -690,11 +690,11 @@ const p35 = p.then(undefined, () => null);
 >p.then(undefined, () => null) : Promise<boolean | null>
 >                              : ^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => null : () => null
@@ -706,11 +706,11 @@ const p36 = p.then(undefined, () => {});
 >p.then(undefined, () => {}) : Promise<boolean | void>
 >                            : ^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => {} : () => void
@@ -722,11 +722,11 @@ const p37 = p.then(undefined, () => {throw 1});
 >p.then(undefined, () => {throw 1}) : Promise<boolean>
 >                                   : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => {throw 1} : () => never
@@ -740,11 +740,11 @@ const p38 = p.then(undefined, () => Promise.resolve(1));
 >p.then(undefined, () => Promise.resolve(1)) : Promise<number | boolean>
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => Promise.resolve(1) : () => Promise<number>
@@ -766,11 +766,11 @@ const p39 = p.then(undefined, () => Promise.reject(1));
 >p.then(undefined, () => Promise.reject(1)) : Promise<boolean>
 >                                           : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 >() => Promise.reject(1) : () => Promise<never>
@@ -792,11 +792,11 @@ const p40 = p.then(null, undefined);
 >p.then(null, undefined) : Promise<boolean>
 >                        : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >undefined : undefined
 >          : ^^^^^^^^^
 
@@ -806,11 +806,11 @@ const p41 = p.then(null, null);
 >p.then(null, null) : Promise<boolean>
 >                   : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const p42 = p.then(null, () => 1);
 >p42 : Promise<number | boolean>
@@ -818,11 +818,11 @@ const p42 = p.then(null, () => 1);
 >p.then(null, () => 1) : Promise<number | boolean>
 >                      : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
 >1 : 1
@@ -834,11 +834,11 @@ const p43 = p.then(null, () => x);
 >p.then(null, () => x) : Promise<any>
 >                      : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -849,11 +849,11 @@ const p44 = p.then(null, () => undefined);
 >p.then(null, () => undefined) : Promise<boolean | undefined>
 >                              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => undefined
 >                : ^^^^^^^^^^^^^^^
 >undefined : undefined
@@ -865,11 +865,11 @@ const p45 = p.then(null, () => null);
 >p.then(null, () => null) : Promise<boolean | null>
 >                         : ^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => null
 >           : ^^^^^^^^^^
 
@@ -879,11 +879,11 @@ const p46 = p.then(null, () => {});
 >p.then(null, () => {}) : Promise<boolean | void>
 >                       : ^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 
@@ -893,11 +893,11 @@ const p47 = p.then(null, () => {throw 1});
 >p.then(null, () => {throw 1}) : Promise<boolean>
 >                              : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -909,11 +909,11 @@ const p48 = p.then(null, () => Promise.resolve(1));
 >p.then(null, () => Promise.resolve(1)) : Promise<number | boolean>
 >                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve(1) : () => Promise<number>
 >                         : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve(1) : Promise<number>
@@ -933,11 +933,11 @@ const p49 = p.then(null, () => Promise.reject(1));
 >p.then(null, () => Promise.reject(1)) : Promise<boolean>
 >                                      : ^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject(1) : () => Promise<never>
 >                        : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject(1) : Promise<never>
@@ -957,11 +957,11 @@ const p50 = p.then(() => "1", undefined);
 >p.then(() => "1", undefined) : Promise<string>
 >                             : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -975,11 +975,11 @@ const p51 = p.then(() => "1", null);
 >p.then(() => "1", null) : Promise<string>
 >                        : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -991,11 +991,11 @@ const p52 = p.then(() => "1", () => 1);
 >p.then(() => "1", () => 1) : Promise<string | number>
 >                           : ^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1011,11 +1011,11 @@ const p53 = p.then(() => "1", () => x);
 >p.then(() => "1", () => x) : Promise<any>
 >                           : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1030,11 +1030,11 @@ const p54 = p.then(() => "1", () => undefined);
 >p.then(() => "1", () => undefined) : Promise<string | undefined>
 >                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1050,11 +1050,11 @@ const p55 = p.then(() => "1", () => null);
 >p.then(() => "1", () => null) : Promise<string | null>
 >                              : ^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1068,11 +1068,11 @@ const p56 = p.then(() => "1", () => {});
 >p.then(() => "1", () => {}) : Promise<string | void>
 >                            : ^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1086,11 +1086,11 @@ const p57 = p.then(() => "1", () => {throw 1});
 >p.then(() => "1", () => {throw 1}) : Promise<string>
 >                                   : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1106,11 +1106,11 @@ const p58 = p.then(() => "1", () => Promise.resolve(1));
 >p.then(() => "1", () => Promise.resolve(1)) : Promise<string | number>
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1134,11 +1134,11 @@ const p59 = p.then(() => "1", () => Promise.reject(1));
 >p.then(() => "1", () => Promise.reject(1)) : Promise<string>
 >                                           : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => "1" : () => string
 >          : ^^^^^^^^^^^^
 >"1" : "1"
@@ -1162,11 +1162,11 @@ const p60 = p.then(() => x, undefined);
 >p.then(() => x, undefined) : Promise<any>
 >                           : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1179,11 +1179,11 @@ const p61 = p.then(() => x, null);
 >p.then(() => x, null) : Promise<any>
 >                      : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1194,11 +1194,11 @@ const p62 = p.then(() => x, () => 1);
 >p.then(() => x, () => 1) : Promise<any>
 >                         : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1213,11 +1213,11 @@ const p63 = p.then(() => x, () => x);
 >p.then(() => x, () => x) : Promise<any>
 >                         : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1231,11 +1231,11 @@ const p64 = p.then(() => x, () => undefined);
 >p.then(() => x, () => undefined) : Promise<any>
 >                                 : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1250,11 +1250,11 @@ const p65 = p.then(() => x, () => null);
 >p.then(() => x, () => null) : Promise<any>
 >                            : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1267,11 +1267,11 @@ const p66 = p.then(() => x, () => {});
 >p.then(() => x, () => {}) : Promise<any>
 >                          : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1284,11 +1284,11 @@ const p67 = p.then(() => x, () => {throw 1});
 >p.then(() => x, () => {throw 1}) : Promise<any>
 >                                 : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1303,11 +1303,11 @@ const p68 = p.then(() => x, () => Promise.resolve(1));
 >p.then(() => x, () => Promise.resolve(1)) : Promise<any>
 >                                          : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1330,11 +1330,11 @@ const p69 = p.then(() => x, () => Promise.reject(1));
 >p.then(() => x, () => Promise.reject(1)) : Promise<any>
 >                                         : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => x : () => any
 >        : ^^^^^^^^^
 >x : any
@@ -1357,11 +1357,11 @@ const p70 = p.then(() => undefined, undefined);
 >p.then(() => undefined, undefined) : Promise<undefined>
 >                                   : ^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => undefined
 >                : ^^^^^^^^^^^^^^^
 >undefined : undefined
@@ -1375,11 +1375,11 @@ const p71 = p.then(() => undefined, null);
 >p.then(() => undefined, null) : Promise<undefined>
 >                              : ^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => undefined
 >                : ^^^^^^^^^^^^^^^
 >undefined : undefined
@@ -1391,11 +1391,11 @@ const p72 = p.then(() => undefined, () => 1);
 >p.then(() => undefined, () => 1) : Promise<number | undefined>
 >                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => undefined
 >                : ^^^^^^^^^^^^^^^
 >undefined : undefined
@@ -1411,11 +1411,11 @@ const p73 = p.then(() => undefined, () => x);
 >p.then(() => undefined, () => x) : Promise<any>
 >                                 : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => undefined
 >                : ^^^^^^^^^^^^^^^
 >undefined : undefined
@@ -1430,11 +1430,11 @@ const p74 = p.then(() => undefined, () => undefined);
 >p.then(() => undefined, () => undefined) : Promise<undefined>
 >                                         : ^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => undefined
 >                : ^^^^^^^^^^^^^^^
 >undefined : undefined
@@ -1450,11 +1450,11 @@ const p75 = p.then(() => undefined, () => null);
 >p.then(() => undefined, () => null) : Promise<null | undefined>
 >                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => undefined
 >                : ^^^^^^^^^^^^^^^
 >undefined : undefined
@@ -1468,11 +1468,11 @@ const p76 = p.then(() => undefined, () => {});
 >p.then(() => undefined, () => {}) : Promise<void | undefined>
 >                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => undefined
 >                : ^^^^^^^^^^^^^^^
 >undefined : undefined
@@ -1486,11 +1486,11 @@ const p77 = p.then(() => undefined, () => {throw 1});
 >p.then(() => undefined, () => {throw 1}) : Promise<undefined>
 >                                         : ^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => undefined
 >                : ^^^^^^^^^^^^^^^
 >undefined : undefined
@@ -1506,11 +1506,11 @@ const p78 = p.then(() => undefined, () => Promise.resolve(1));
 >p.then(() => undefined, () => Promise.resolve(1)) : Promise<number | undefined>
 >                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => undefined
 >                : ^^^^^^^^^^^^^^^
 >undefined : undefined
@@ -1534,11 +1534,11 @@ const p79 = p.then(() => undefined, () => Promise.reject(1));
 >p.then(() => undefined, () => Promise.reject(1)) : Promise<undefined>
 >                                                 : ^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => undefined : () => undefined
 >                : ^^^^^^^^^^^^^^^
 >undefined : undefined
@@ -1562,11 +1562,11 @@ const p80 = p.then(() => null, undefined);
 >p.then(() => null, undefined) : Promise<null>
 >                              : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => null
 >           : ^^^^^^^^^^
 >undefined : undefined
@@ -1578,11 +1578,11 @@ const p81 = p.then(() => null, null);
 >p.then(() => null, null) : Promise<null>
 >                         : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => null
 >           : ^^^^^^^^^^
 
@@ -1592,11 +1592,11 @@ const p82 = p.then(() => null, () => 1);
 >p.then(() => null, () => 1) : Promise<number | null>
 >                            : ^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => null
 >           : ^^^^^^^^^^
 >() => 1 : () => number
@@ -1610,11 +1610,11 @@ const p83 = p.then(() => null, () => x);
 >p.then(() => null, () => x) : Promise<any>
 >                            : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => null
 >           : ^^^^^^^^^^
 >() => x : () => any
@@ -1627,11 +1627,11 @@ const p84 = p.then(() => null, () => undefined);
 >p.then(() => null, () => undefined) : Promise<null | undefined>
 >                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => null
 >           : ^^^^^^^^^^
 >() => undefined : () => undefined
@@ -1645,11 +1645,11 @@ const p85 = p.then(() => null, () => null);
 >p.then(() => null, () => null) : Promise<null>
 >                               : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => null
 >           : ^^^^^^^^^^
 >() => null : () => null
@@ -1661,11 +1661,11 @@ const p86 = p.then(() => null, () => {});
 >p.then(() => null, () => {}) : Promise<void | null>
 >                             : ^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => null
 >           : ^^^^^^^^^^
 >() => {} : () => void
@@ -1677,11 +1677,11 @@ const p87 = p.then(() => null, () => {throw 1});
 >p.then(() => null, () => {throw 1}) : Promise<null>
 >                                    : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => null
 >           : ^^^^^^^^^^
 >() => {throw 1} : () => never
@@ -1695,11 +1695,11 @@ const p88 = p.then(() => null, () => Promise.resolve(1));
 >p.then(() => null, () => Promise.resolve(1)) : Promise<number | null>
 >                                             : ^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => null
 >           : ^^^^^^^^^^
 >() => Promise.resolve(1) : () => Promise<number>
@@ -1721,11 +1721,11 @@ const p89 = p.then(() => null, () => Promise.reject(1));
 >p.then(() => null, () => Promise.reject(1)) : Promise<null>
 >                                            : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => null : () => null
 >           : ^^^^^^^^^^
 >() => Promise.reject(1) : () => Promise<never>
@@ -1747,11 +1747,11 @@ const p90 = p.then(() => {}, undefined);
 >p.then(() => {}, undefined) : Promise<void>
 >                            : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >undefined : undefined
@@ -1763,11 +1763,11 @@ const p91 = p.then(() => {}, null);
 >p.then(() => {}, null) : Promise<void>
 >                       : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 
@@ -1777,11 +1777,11 @@ const p92 = p.then(() => {}, () => 1);
 >p.then(() => {}, () => 1) : Promise<number | void>
 >                          : ^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => 1 : () => number
@@ -1795,11 +1795,11 @@ const p93 = p.then(() => {}, () => x);
 >p.then(() => {}, () => x) : Promise<any>
 >                          : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => x : () => any
@@ -1812,11 +1812,11 @@ const p94 = p.then(() => {}, () => undefined);
 >p.then(() => {}, () => undefined) : Promise<void | undefined>
 >                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => undefined : () => undefined
@@ -1830,11 +1830,11 @@ const p95 = p.then(() => {}, () => null);
 >p.then(() => {}, () => null) : Promise<void | null>
 >                             : ^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => null : () => null
@@ -1846,11 +1846,11 @@ const p96 = p.then(() => {}, () => {});
 >p.then(() => {}, () => {}) : Promise<void>
 >                           : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => {} : () => void
@@ -1862,11 +1862,11 @@ const p97 = p.then(() => {}, () => {throw 1});
 >p.then(() => {}, () => {throw 1}) : Promise<void>
 >                                  : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => {throw 1} : () => never
@@ -1880,11 +1880,11 @@ const p98 = p.then(() => {}, () => Promise.resolve(1));
 >p.then(() => {}, () => Promise.resolve(1)) : Promise<number | void>
 >                                           : ^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => Promise.resolve(1) : () => Promise<number>
@@ -1906,11 +1906,11 @@ const p99 = p.then(() => {}, () => Promise.reject(1));
 >p.then(() => {}, () => Promise.reject(1)) : Promise<void>
 >                                          : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {} : () => void
 >         : ^^^^^^^^^^
 >() => Promise.reject(1) : () => Promise<never>
@@ -1932,11 +1932,11 @@ const pa0 = p.then(() => {throw 1}, undefined);
 >p.then(() => {throw 1}, undefined) : Promise<never>
 >                                   : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -1950,11 +1950,11 @@ const pa1 = p.then(() => {throw 1}, null);
 >p.then(() => {throw 1}, null) : Promise<never>
 >                              : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -1966,11 +1966,11 @@ const pa2 = p.then(() => {throw 1}, () => 1);
 >p.then(() => {throw 1}, () => 1) : Promise<number>
 >                                 : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -1986,11 +1986,11 @@ const pa3 = p.then(() => {throw 1}, () => x);
 >p.then(() => {throw 1}, () => x) : Promise<any>
 >                                 : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2005,11 +2005,11 @@ const pa4 = p.then(() => {throw 1}, () => undefined);
 >p.then(() => {throw 1}, () => undefined) : Promise<undefined>
 >                                         : ^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2025,11 +2025,11 @@ const pa5 = p.then(() => {throw 1}, () => null);
 >p.then(() => {throw 1}, () => null) : Promise<null>
 >                                    : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2043,11 +2043,11 @@ const pa6 = p.then(() => {throw 1}, () => {});
 >p.then(() => {throw 1}, () => {}) : Promise<void>
 >                                  : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2061,11 +2061,11 @@ const pa7 = p.then(() => {throw 1}, () => {throw 1});
 >p.then(() => {throw 1}, () => {throw 1}) : Promise<never>
 >                                         : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2081,11 +2081,11 @@ const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >p.then(() => {throw 1}, () => Promise.resolve(1)) : Promise<number>
 >                                                  : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2109,11 +2109,11 @@ const pa9 = p.then(() => {throw 1}, () => Promise.reject(1));
 >p.then(() => {throw 1}, () => Promise.reject(1)) : Promise<never>
 >                                                 : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => {throw 1} : () => never
 >                : ^^^^^^^^^^^
 >1 : 1
@@ -2137,11 +2137,11 @@ const pb0 = p.then(() => Promise.resolve("1"), undefined);
 >p.then(() => Promise.resolve("1"), undefined) : Promise<string>
 >                                              : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2163,11 +2163,11 @@ const pb1 = p.then(() => Promise.resolve("1"), null);
 >p.then(() => Promise.resolve("1"), null) : Promise<string>
 >                                         : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2187,11 +2187,11 @@ const pb2 = p.then(() => Promise.resolve("1"), () => 1);
 >p.then(() => Promise.resolve("1"), () => 1) : Promise<string | number>
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2215,11 +2215,11 @@ const pb3 = p.then(() => Promise.resolve("1"), () => x);
 >p.then(() => Promise.resolve("1"), () => x) : Promise<any>
 >                                            : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2242,11 +2242,11 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined);
 >p.then(() => Promise.resolve("1"), () => undefined) : Promise<string | undefined>
 >                                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2270,11 +2270,11 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null);
 >p.then(() => Promise.resolve("1"), () => null) : Promise<string | null>
 >                                               : ^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2296,11 +2296,11 @@ const pb6 = p.then(() => Promise.resolve("1"), () => {});
 >p.then(() => Promise.resolve("1"), () => {}) : Promise<string | void>
 >                                             : ^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2322,11 +2322,11 @@ const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >p.then(() => Promise.resolve("1"), () => {throw 1}) : Promise<string>
 >                                                    : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2350,11 +2350,11 @@ const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >p.then(() => Promise.resolve("1"), () => Promise.resolve(1)) : Promise<string | number>
 >                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2386,11 +2386,11 @@ const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >p.then(() => Promise.resolve("1"), () => Promise.reject(1)) : Promise<string>
 >                                                            : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.resolve("1") : () => Promise<string>
 >                           : ^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve("1") : Promise<string>
@@ -2422,11 +2422,11 @@ const pc0 = p.then(() => Promise.reject("1"), undefined);
 >p.then(() => Promise.reject("1"), undefined) : Promise<never>
 >                                             : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2448,11 +2448,11 @@ const pc1 = p.then(() => Promise.reject("1"), null);
 >p.then(() => Promise.reject("1"), null) : Promise<never>
 >                                        : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2472,11 +2472,11 @@ const pc2 = p.then(() => Promise.reject("1"), () => 1);
 >p.then(() => Promise.reject("1"), () => 1) : Promise<number>
 >                                           : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2500,11 +2500,11 @@ const pc3 = p.then(() => Promise.reject("1"), () => x);
 >p.then(() => Promise.reject("1"), () => x) : Promise<any>
 >                                           : ^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2527,11 +2527,11 @@ const pc4 = p.then(() => Promise.reject("1"), () => undefined);
 >p.then(() => Promise.reject("1"), () => undefined) : Promise<undefined>
 >                                                   : ^^^^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2555,11 +2555,11 @@ const pc5 = p.then(() => Promise.reject("1"), () => null);
 >p.then(() => Promise.reject("1"), () => null) : Promise<null>
 >                                              : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2581,11 +2581,11 @@ const pc6 = p.then(() => Promise.reject("1"), () => {});
 >p.then(() => Promise.reject("1"), () => {}) : Promise<void>
 >                                            : ^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2607,11 +2607,11 @@ const pc7 = p.then(() => Promise.reject("1"), () => {throw 1});
 >p.then(() => Promise.reject("1"), () => {throw 1}) : Promise<never>
 >                                                   : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2635,11 +2635,11 @@ const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1));
 >p.then(() => Promise.reject("1"), () => Promise.resolve(1)) : Promise<number>
 >                                                            : ^^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
@@ -2671,11 +2671,11 @@ const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1));
 >p.then(() => Promise.reject("1"), () => Promise.reject(1)) : Promise<never>
 >                                                           : ^^^^^^^^^^^^^^
 >p.then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<boolean>
 >  : ^^^^^^^^^^^^^^^^
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => Promise.reject("1") : () => Promise<never>
 >                          : ^^^^^^^^^^^^^^^^^^^^
 >Promise.reject("1") : Promise<never>
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.types b/tests/baselines/reference/promiseVoidErrorCallback.types
index fa4cd1f7188cd..1ab8bcbae7475 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.types
+++ b/tests/baselines/reference/promiseVoidErrorCallback.types
@@ -69,11 +69,11 @@ var x3 = f1()
 >f1()    .then(f2, (e: Error) => {    throw e;})    .then((x: T2) => {    return { __t3: x.__t2 + "bar" };}) : Promise<{ __t3: string; }>
 >                                                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >f1()    .then(f2, (e: Error) => {    throw e;})    .then : <TResult1 = T2, TResult2 = never>(onfulfilled?: (value: T2) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                                                         : ^        ^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                                                         : ^        ^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >f1()    .then(f2, (e: Error) => {    throw e;}) : Promise<T2>
 >                                                : ^^^^^^^^^^^
 >f1()    .then : <TResult1 = T1, TResult2 = never>(onfulfilled?: (value: T1) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->              : ^        ^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>              : ^        ^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >f1() : Promise<T1>
 >     : ^^^^^^^^^^^
 >f1 : () => Promise<T1>
@@ -81,7 +81,7 @@ var x3 = f1()
 
     .then(f2, (e: Error) => {
 >then : <TResult1 = T1, TResult2 = never>(onfulfilled?: (value: T1) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >f2 : (x: T1) => T2
 >   : ^ ^^  ^^^^^  
 >(e: Error) => {    throw e;} : (e: Error) => never
@@ -96,7 +96,7 @@ var x3 = f1()
 })
     .then((x: T2) => {
 >then : <TResult1 = T2, TResult2 = never>(onfulfilled?: (value: T2) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(x: T2) => {    return { __t3: x.__t2 + "bar" };} : (x: T2) => { __t3: string; }
 >                                                  : ^ ^^  ^^^^^^^^^^^^^^^^^^^^^^
 >x : T2
diff --git a/tests/baselines/reference/propagationOfPromiseInitialization.types b/tests/baselines/reference/propagationOfPromiseInitialization.types
index e2be5df8e2424..361d37b5b2354 100644
--- a/tests/baselines/reference/propagationOfPromiseInitialization.types
+++ b/tests/baselines/reference/propagationOfPromiseInitialization.types
@@ -22,15 +22,15 @@ foo.then((x) => {
 >foo.then((x) => {    // x is inferred to be a number    return "asdf";}).then((x) => {    // x is inferred to be string    x.length;    return 123;}) : IPromise<number>
 >                                                                                                                                                      : ^^^^^^^^^^^^^^^^
 >foo.then((x) => {    // x is inferred to be a number    return "asdf";}).then : <TResult>(successCallback: (promiseValue: string) => TResult, errorCallback?: (reason: any) => TResult) => IPromise<TResult>
->                                                                              : ^       ^^               ^^^            ^^^^^^^^^^^^^^^^^^^^^^             ^^^^      ^^   ^^^^^^^^^^^^^^^^^         ^^^^^^^ 
+>                                                                              : ^       ^^               ^^^            ^^^^^^^^^^^^^^^^^^^^^^             ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >foo.then((x) => {    // x is inferred to be a number    return "asdf";}) : IPromise<string>
 >                                                                         : ^^^^^^^^^^^^^^^^
 >foo.then : <TResult>(successCallback: (promiseValue: number) => TResult, errorCallback?: (reason: any) => TResult) => IPromise<TResult>
->         : ^       ^^               ^^^            ^^^^^^^^^^^^^^^^^^^^^^             ^^^^      ^^   ^^^^^^^^^^^^^^^^^         ^^^^^^^ 
+>         : ^       ^^               ^^^            ^^^^^^^^^^^^^^^^^^^^^^             ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >foo : IPromise<number>
 >    : ^^^^^^^^^^^^^^^^
 >then : <TResult>(successCallback: (promiseValue: number) => TResult, errorCallback?: (reason: any) => TResult) => IPromise<TResult>
->     : ^       ^^               ^^^            ^^^^^^^^^^^^^^^^^^^^^^             ^^^^      ^^   ^^^^^^^^^^^^^^^^^         ^^^^^^^ 
+>     : ^       ^^               ^^^            ^^^^^^^^^^^^^^^^^^^^^^             ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(x) => {    // x is inferred to be a number    return "asdf";} : (x: number) => string
 >                                                               : ^ ^^^^^^^^^^^^^^^^^^^
 >x : number
@@ -43,7 +43,7 @@ foo.then((x) => {
 
 }).then((x) => {
 >then : <TResult>(successCallback: (promiseValue: string) => TResult, errorCallback?: (reason: any) => TResult) => IPromise<TResult>
->     : ^       ^^               ^^^            ^^^^^^^^^^^^^^^^^^^^^^             ^^^^      ^^   ^^^^^^^^^^^^^^^^^         ^^^^^^^ 
+>     : ^       ^^               ^^^            ^^^^^^^^^^^^^^^^^^^^^^             ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(x) => {    // x is inferred to be string    x.length;    return 123;} : (x: string) => number
 >                                                                       : ^ ^^^^^^^^^^^^^^^^^^^
 >x : string
diff --git a/tests/baselines/reference/propertyAccessWidening.types b/tests/baselines/reference/propertyAccessWidening.types
index 710ea4bedf22a..9ad11c7d6dc0f 100644
--- a/tests/baselines/reference/propertyAccessWidening.types
+++ b/tests/baselines/reference/propertyAccessWidening.types
@@ -31,7 +31,7 @@ function g1(headerNames: any) {
 >[{cells: headerNames }].concat(t) : { cells: any; }[]
 >                                  : ^^^^^^^^^^^^^^^^^
 >[{cells: headerNames }].concat : { (...items: ConcatArray<{ cells: any; }>[]): { cells: any; }[]; (...items: ({ cells: any; } | ConcatArray<{ cells: any; }>)[]): { cells: any; }[]; }
->                               : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>                               : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[{cells: headerNames }] : { cells: any; }[]
 >                        : ^^^^^^^^^^^^^^^^^
 >{cells: headerNames } : { cells: any; }
@@ -41,7 +41,7 @@ function g1(headerNames: any) {
 >headerNames : any
 >            : ^^^
 >concat : { (...items: ConcatArray<{ cells: any; }>[]): { cells: any; }[]; (...items: ({ cells: any; } | ConcatArray<{ cells: any; }>)[]): { cells: any; }[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >t : { hasLineBreak: boolean; cells: never[]; }[]
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 }
@@ -74,7 +74,7 @@ function g2(headerNames: any) {
 >[{cells: headerNames }]["concat"](t) : { cells: any; }[]
 >                                     : ^^^^^^^^^^^^^^^^^
 >[{cells: headerNames }]["concat"] : { (...items: ConcatArray<{ cells: any; }>[]): { cells: any; }[]; (...items: ({ cells: any; } | ConcatArray<{ cells: any; }>)[]): { cells: any; }[]; }
->                                  : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>                                  : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[{cells: headerNames }] : { cells: any; }[]
 >                        : ^^^^^^^^^^^^^^^^^
 >{cells: headerNames } : { cells: any; }
diff --git a/tests/baselines/reference/quickInfoCircularInstantiationExpression.baseline b/tests/baselines/reference/quickInfoCircularInstantiationExpression.baseline
index aa6ab71613e73..2c190b11c4378 100644
--- a/tests/baselines/reference/quickInfoCircularInstantiationExpression.baseline
+++ b/tests/baselines/reference/quickInfoCircularInstantiationExpression.baseline
@@ -4,7 +4,7 @@
 // foo("");
 // ^^^
 // | ----------------------------------------------------------------------
-// | function foo<string>(t: string): typeof foo<string>
+// | function foo<string>(t: string): (t: string) => ...
 // | ----------------------------------------------------------------------
 
 [
@@ -79,28 +79,44 @@
           "kind": "space"
         },
         {
-          "text": "typeof",
-          "kind": "keyword"
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "t",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
         },
         {
           "text": " ",
           "kind": "space"
         },
         {
-          "text": "foo",
-          "kind": "functionName"
+          "text": "string",
+          "kind": "keyword"
         },
         {
-          "text": "<",
+          "text": ")",
           "kind": "punctuation"
         },
         {
-          "text": "string",
-          "kind": "keyword"
+          "text": " ",
+          "kind": "space"
         },
         {
-          "text": ">",
+          "text": "=>",
           "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "...",
+          "kind": "text"
         }
       ],
       "documentation": []
diff --git a/tests/baselines/reference/recursiveArrayNotCircular.types b/tests/baselines/reference/recursiveArrayNotCircular.types
index 387f8084491d3..efa256e85907a 100644
--- a/tests/baselines/reference/recursiveArrayNotCircular.types
+++ b/tests/baselines/reference/recursiveArrayNotCircular.types
@@ -150,7 +150,7 @@ function reducer(action: ReducerAction): void {
 >action.payload.map(reducer) : void[]
 >                            : ^^^^^^
 >action.payload.map : <U>(callbackfn: (value: ReducerAction, index: number, array: ReducerAction[]) => U, thisArg?: any) => U[]
->                   : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                   : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >action.payload : ReducerAction[]
 >               : ^^^^^^^^^^^^^^^
 >action : { type: ActionType.Batch; payload: ReducerAction[]; }
@@ -158,7 +158,7 @@ function reducer(action: ReducerAction): void {
 >payload : ReducerAction[]
 >        : ^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: ReducerAction, index: number, array: ReducerAction[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >reducer : (action: ReducerAction) => void
 >        : ^      ^^             ^^^^^    
 
diff --git a/tests/baselines/reference/recursiveTypeAliasWithSpreadConditionalReturnNotCircular.types b/tests/baselines/reference/recursiveTypeAliasWithSpreadConditionalReturnNotCircular.types
index 2a79cf873302e..b18cc9a4be177 100644
--- a/tests/baselines/reference/recursiveTypeAliasWithSpreadConditionalReturnNotCircular.types
+++ b/tests/baselines/reference/recursiveTypeAliasWithSpreadConditionalReturnNotCircular.types
@@ -58,11 +58,11 @@ const zipped1 = opt1.zip1(opt2, opt3);
 >opt1.zip1(opt2, opt3) : Option<[number, string, boolean]>
 >                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >opt1.zip1 : <O extends Array<Option<any>>>(...others: O) => Option<[number, ...UnzipOptionArray1<O>]>
->          : ^ ^^^^^^^^^                  ^^^^^      ^^^^^^^^        ^^^^^^                       ^   
+>          : ^ ^^^^^^^^^                  ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >opt1 : Option<number>
 >     : ^^^^^^^^^^^^^^
 >zip1 : <O extends Array<Option<any>>>(...others: O) => Option<[number, ...UnzipOptionArray1<O>]>
->     : ^ ^^^^^^^^^                  ^^^^^      ^^^^^^^^        ^^^^^^                       ^   
+>     : ^ ^^^^^^^^^                  ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >opt2 : Option<string>
 >     : ^^^^^^^^^^^^^^
 >opt3 : Option<boolean>
@@ -74,11 +74,11 @@ const zipped2 = opt1.zip2(opt2, opt3);
 >opt1.zip2(opt2, opt3) : Option<[number, string, boolean]>
 >                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >opt1.zip2 : <O extends Array<Option<any>>>(...others: O) => Option<[number, ...UnzipOptionArray2<O>]>
->          : ^ ^^^^^^^^^                  ^^^^^      ^^^^^^^^        ^^^^^^                       ^   
+>          : ^ ^^^^^^^^^                  ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >opt1 : Option<number>
 >     : ^^^^^^^^^^^^^^
 >zip2 : <O extends Array<Option<any>>>(...others: O) => Option<[number, ...UnzipOptionArray2<O>]>
->     : ^ ^^^^^^^^^                  ^^^^^      ^^^^^^^^        ^^^^^^                       ^   
+>     : ^ ^^^^^^^^^                  ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >opt2 : Option<string>
 >     : ^^^^^^^^^^^^^^
 >opt3 : Option<boolean>
@@ -90,11 +90,11 @@ const zipped3 = opt1.zip3(opt2, opt3);
 >opt1.zip3(opt2, opt3) : Option<[number, string, boolean]>
 >                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >opt1.zip3 : <O extends Array<Option<any>>>(...others: O) => Option<[number, ...UnzipOptionArray3<O>]>
->          : ^ ^^^^^^^^^                  ^^^^^      ^^^^^^^^        ^^^^^^                       ^   
+>          : ^ ^^^^^^^^^                  ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >opt1 : Option<number>
 >     : ^^^^^^^^^^^^^^
 >zip3 : <O extends Array<Option<any>>>(...others: O) => Option<[number, ...UnzipOptionArray3<O>]>
->     : ^ ^^^^^^^^^                  ^^^^^      ^^^^^^^^        ^^^^^^                       ^   
+>     : ^ ^^^^^^^^^                  ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >opt2 : Option<string>
 >     : ^^^^^^^^^^^^^^
 >opt3 : Option<boolean>
diff --git a/tests/baselines/reference/recursiveTypeReferences1.types b/tests/baselines/reference/recursiveTypeReferences1.types
index e0dc965a24b92..db0722b2e0c3e 100644
--- a/tests/baselines/reference/recursiveTypeReferences1.types
+++ b/tests/baselines/reference/recursiveTypeReferences1.types
@@ -684,11 +684,11 @@ function parse(node: Tree, index: number[] = []): HTMLUListElement {
 >node.map(([el, children], i) => {    const idx = [...index, i + 1];    return html('li', [      html('a', { href: `#${el.id}`, rel: 'noopener', 'data-index': idx.join('.') }, el.textContent!),      children.length > 0 ? parse(children, idx) : frag()    ]);  }) : any[]
 >                                                                                                                                                                                                                                                                     : ^^^^^
 >node.map : <U>(callbackfn: (value: [HTMLHeadingElement, Tree], index: number, array: [HTMLHeadingElement, Tree][]) => U, thisArg?: any) => U[]
->         : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>         : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >node : Tree
 >     : ^^^^
 >map : <U>(callbackfn: (value: [HTMLHeadingElement, Tree], index: number, array: [HTMLHeadingElement, Tree][]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >([el, children], i) => {    const idx = [...index, i + 1];    return html('li', [      html('a', { href: `#${el.id}`, rel: 'noopener', 'data-index': idx.join('.') }, el.textContent!),      children.length > 0 ? parse(children, idx) : frag()    ]);  } : ([el, children]: [HTMLHeadingElement, Tree], i: number) => any
 >                                                                                                                                                                                                                                                           : ^              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
 >el : HTMLHeadingElement
@@ -834,11 +834,11 @@ function cons(hs: HTMLHeadingElement[]): Tree {
 >hss.pop() : HTMLHeadingElement[] | undefined
 >          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >hss.pop : () => HTMLHeadingElement[] | undefined
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^            
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >hss : HTMLHeadingElement[][]
 >    : ^^^^^^^^^^^^^^^^^^^^^^
 >pop : () => HTMLHeadingElement[] | undefined
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^            
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
       return hs.length === 0 || level(h) > level(hs[0])
 >hs.length === 0 || level(h) > level(hs[0])        ? concat(hss, [concat(hs, [h])])        : concat(hss, [hs, [h]]) : any
@@ -960,11 +960,11 @@ function cons(hs: HTMLHeadingElement[]): Tree {
 >hs.shift() : HTMLHeadingElement | undefined
 >           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >hs.shift : () => HTMLHeadingElement | undefined
->         : ^^^^^^^^^^^^^^^^^^^^^^^^            
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >hs : HTMLHeadingElement[]
 >   : ^^^^^^^^^^^^^^^^^^^^
 >shift : () => HTMLHeadingElement | undefined
->      : ^^^^^^^^^^^^^^^^^^^^^^^^            
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >cons(hs) : Tree
 >         : ^^^^
 >cons : (hs: HTMLHeadingElement[]) => Tree
diff --git a/tests/baselines/reference/recursiveTypeRelations.types b/tests/baselines/reference/recursiveTypeRelations.types
index 5e0fb337a1b7c..14fc3c854d501 100644
--- a/tests/baselines/reference/recursiveTypeRelations.types
+++ b/tests/baselines/reference/recursiveTypeRelations.types
@@ -53,11 +53,11 @@ export function css<S extends { [K in keyof S]: string }>(styles: S, ...classNam
 >classNames.map(arg => {    if (arg == null) {      return null;    }    if (typeof arg == "string") {      return styles[arg];    }    if (typeof arg == "object") {      return Object.keys(arg).reduce<ClassNameObject>((obj: ClassNameObject, key: keyof S) => {        const exportedClassName = styles[key];        obj[exportedClassName] = (arg as ClassNameMap<S>)[key];         return obj;      }, {});    }  }) : string[]
 >                                                                                                                                                                                                                                                                                                                                                                                                                           : ^^^^^^^^
 >classNames.map : <U>(callbackfn: (value: ClassNameArg<S>, index: number, array: ClassNameArg<S>[]) => U, thisArg?: any) => U[]
->               : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>               : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >classNames : ClassNameArg<S>[]
 >           : ^^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: ClassNameArg<S>, index: number, array: ClassNameArg<S>[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >arg => {    if (arg == null) {      return null;    }    if (typeof arg == "string") {      return styles[arg];    }    if (typeof arg == "object") {      return Object.keys(arg).reduce<ClassNameObject>((obj: ClassNameObject, key: keyof S) => {        const exportedClassName = styles[key];        obj[exportedClassName] = (arg as ClassNameMap<S>)[key];         return obj;      }, {});    }  } : (arg: ClassNameArg<S>) => string
 >                                                                                                                                                                                                                                                                                                                                                                                                           : ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >arg : ClassNameArg<S>
diff --git a/tests/baselines/reference/restElementWithNumberPropertyName.types b/tests/baselines/reference/restElementWithNumberPropertyName.types
index 1bb8bf6ff316f..9010971b8437e 100644
--- a/tests/baselines/reference/restElementWithNumberPropertyName.types
+++ b/tests/baselines/reference/restElementWithNumberPropertyName.types
@@ -4,8 +4,8 @@
 const { 0: a, ...b } = [0, 1, 2];
 >a : number
 >  : ^^^^^^
->b : { [n: number]: number; 0: number; 1: number; 2: number; length: 3; toString(): string; toLocaleString(): string; pop(): number | undefined; push(...items: number[]): number; concat(...items: ConcatArray<number>[]): number[]; concat(...items: (number | ConcatArray<number>)[]): number[]; join(separator?: string): string; reverse(): number[]; shift(): number | undefined; slice(start?: number, end?: number): number[]; sort(compareFn?: (a: number, b: number) => number): [number, number, number]; splice(start: number, deleteCount?: number): number[]; splice(start: number, deleteCount: number, ...items: number[]): number[]; unshift(...items: number[]): number; indexOf(searchElement: number, fromIndex?: number): number; lastIndexOf(searchElement: number, fromIndex?: number): number; every<S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; some(predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; filter<S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^            ^^^^^^^^^^     ^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^            ^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^  ^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^  ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^     ^^^^^^^^^^^^^      ^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^  ^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^
+>b : { [n: number]: number; 0: number; 1: number; 2: number; length: 3; toString(): string; toLocaleString(): string; pop(): number; push(...items: number[]): number; concat(...items: ConcatArray<number>[]): number[]; concat(...items: (number | ConcatArray<number>)[]): number[]; join(separator?: string): string; reverse(): number[]; shift(): number; slice(start?: number, end?: number): number[]; sort(compareFn?: (a: number, b: number) => number): [number, number, number]; splice(start: number, deleteCount?: number): number[]; splice(start: number, deleteCount: number, ...items: number[]): number[]; unshift(...items: number[]): number; indexOf(searchElement: number, fromIndex?: number): number; lastIndexOf(searchElement: number, fromIndex?: number): number; every<S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; some(predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any): U[]; filter<S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^      ^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^
 >[0, 1, 2] : [number, number, number]
 >          : ^^^^^^^^^^^^^^^^^^^^^^^^
 >0 : 0
diff --git a/tests/baselines/reference/restInvalidArgumentType.types b/tests/baselines/reference/restInvalidArgumentType.types
index 8bfdc3997be11..1406cc6d3e950 100644
--- a/tests/baselines/reference/restInvalidArgumentType.types
+++ b/tests/baselines/reference/restInvalidArgumentType.types
@@ -102,8 +102,8 @@ function f<T extends { b: string }>(p1: T, p2: T[]) {
 >   : ^
 
     var {...r2} = p2;   // OK
->r2 : { [n: number]: T; length: number; toString(): string; toLocaleString(): string; pop(): T | undefined; push(...items: T[]): number; concat(...items: ConcatArray<T>[]): T[]; concat(...items: (T | ConcatArray<T>)[]): T[]; join(separator?: string): string; reverse(): T[]; shift(): T | undefined; slice(start?: number, end?: number): T[]; sort(compareFn?: (a: T, b: T) => number): T[]; splice(start: number, deleteCount?: number): T[]; splice(start: number, deleteCount: number, ...items: T[]): T[]; unshift(...items: T[]): number; indexOf(searchElement: T, fromIndex?: number): number; lastIndexOf(searchElement: T, fromIndex?: number): number; every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^            ^^^^^^^^^^     ^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^  ^^^^^^^^^^^^            ^^^^^^^^     ^^^      ^^   ^^^      ^^^^  ^^^^^^^         ^^^^ ^^^^^ ^^^^^^^^      ^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^  ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^  ^^^^^^^^^^^^^     ^^^^^^^^      ^^^^^^^^^^             ^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^^  ^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^
+>r2 : { [n: number]: T; length: number; toString(): string; toLocaleString(): string; pop(): T; push(...items: T[]): number; concat(...items: ConcatArray<T>[]): T[]; concat(...items: (T | ConcatArray<T>)[]): T[]; join(separator?: string): string; reverse(): T[]; shift(): T; slice(start?: number, end?: number): T[]; sort(compareFn?: (a: T, b: T) => number): T[]; splice(start: number, deleteCount?: number): T[]; splice(start: number, deleteCount: number, ...items: T[]): T[]; unshift(...items: T[]): number; indexOf(searchElement: T, fromIndex?: number): number; lastIndexOf(searchElement: T, fromIndex?: number): number; every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^         ^^^^ ^^^^^ ^^^^^^^^      ^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^      ^^^^^^^^^^             ^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^
 >p2 : T[]
 >   : ^^^
 
diff --git a/tests/baselines/reference/restParameterWithBindingPattern3.types b/tests/baselines/reference/restParameterWithBindingPattern3.types
index 4f8e4184fd7c5..16f198759f95f 100644
--- a/tests/baselines/reference/restParameterWithBindingPattern3.types
+++ b/tests/baselines/reference/restParameterWithBindingPattern3.types
@@ -56,6 +56,6 @@ function e(...{0: a = 1, 1: b = true, ...rest: rest}: [boolean, string, number])
 >     : ^^^^
 >rest : any
 >     : ^^^
->rest : { [n: number]: string | number | boolean; 0: boolean; 1: string; 2: number; length: 3; toString(): string; toLocaleString(): string; pop(): (string | number | boolean) | undefined; push(...items: (string | number | boolean)[]): number; concat(...items: ConcatArray<string | number | boolean>[]): (string | number | boolean)[]; concat(...items: (string | number | boolean | ConcatArray<string | number | boolean>)[]): (string | number | boolean)[]; join(separator?: string): string; reverse(): (string | number | boolean)[]; shift(): (string | number | boolean) | undefined; slice(start?: number, end?: number): (string | number | boolean)[]; sort(compareFn?: (a: string | number | boolean, b: string | number | boolean) => number): [boolean, string, number]; splice(start: number, deleteCount?: number): (string | number | boolean)[]; splice(start: number, deleteCount: number, ...items: (string | number | boolean)[]): (string | number | boolean)[]; unshift(...items: (string | number | boolean)[]): number; indexOf(searchElement: string | number | boolean, fromIndex?: number): number; lastIndexOf(searchElement: string | number | boolean, fromIndex?: number): number; every<S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => unknown, thisArg?: any): boolean; some(predicate: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => U, thisArg?: any): U[]; filter<S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => unknown, thisArg?: any): (string | number | boolean)[]; reduce(callbackfn: (previousValue: string | number | boolean, currentValue: string | number | boolean, currentIndex: number, array: (string | number | boolean)[]) => string | number | boolean): string | number | boolean; reduce(callbackfn: (previousValue: string | number | boolean, currentValue: string | number | boolean, currentIndex: number, array: (string | number | boolean)[]) => string | number | boolean, initialValue: string | number | boolean): string | number | boolean; reduce<U>(callbackfn: (previousValue: U, currentValue: string | number | boolean, currentIndex: number, array: (string | number | boolean)[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: string | number | boolean, currentValue: string | number | boolean, currentIndex: number, array: (string | number | boolean)[]) => string | number | boolean): string | number | boolean; reduceRight(callbackfn: (previousValue: string | number | boolean, currentValue: string | number | boolean, currentIndex: number, array: (string | number | boolean)[]) => string | number | boolean, initialValue: string | number | boolean): string | number | boolean; reduceRight<U>(callbackfn: (previousValue: U, currentValue: string | number | boolean, currentIndex: number, array: (string | number | boolean)[]) => U, initialValue: U): U; }
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^         ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^          ^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^
+>rest : { [n: number]: string | number | boolean; 0: boolean; 1: string; 2: number; length: 3; toString(): string; toLocaleString(): string; pop(): string | number | boolean; push(...items: (string | number | boolean)[]): number; concat(...items: ConcatArray<string | number | boolean>[]): (string | number | boolean)[]; concat(...items: (string | number | boolean | ConcatArray<string | number | boolean>)[]): (string | number | boolean)[]; join(separator?: string): string; reverse(): (string | number | boolean)[]; shift(): string | number | boolean; slice(start?: number, end?: number): (string | number | boolean)[]; sort(compareFn?: (a: string | number | boolean, b: string | number | boolean) => number): [boolean, string, number]; splice(start: number, deleteCount?: number): (string | number | boolean)[]; splice(start: number, deleteCount: number, ...items: (string | number | boolean)[]): (string | number | boolean)[]; unshift(...items: (string | number | boolean)[]): number; indexOf(searchElement: string | number | boolean, fromIndex?: number): number; lastIndexOf(searchElement: string | number | boolean, fromIndex?: number): number; every<S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => unknown, thisArg?: any): boolean; some(predicate: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => U, thisArg?: any): U[]; filter<S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: string | number | boolean, index: number, array: (string | number | boolean)[]) => unknown, thisArg?: any): (string | number | boolean)[]; reduce(callbackfn: (previousValue: string | number | boolean, currentValue: string | number | boolean, currentIndex: number, array: (string | number | boolean)[]) => string | number | boolean): string | number | boolean; reduce(callbackfn: (previousValue: string | number | boolean, currentValue: string | number | boolean, currentIndex: number, array: (string | number | boolean)[]) => string | number | boolean, initialValue: string | number | boolean): string | number | boolean; reduce<U>(callbackfn: (previousValue: U, currentValue: string | number | boolean, currentIndex: number, array: (string | number | boolean)[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: string | number | boolean, currentValue: string | number | boolean, currentIndex: number, array: (string | number | boolean)[]) => string | number | boolean): string | number | boolean; reduceRight(callbackfn: (previousValue: string | number | boolean, currentValue: string | number | boolean, currentIndex: number, array: (string | number | boolean)[]) => string | number | boolean, initialValue: string | number | boolean): string | number | boolean; reduceRight<U>(callbackfn: (previousValue: U, currentValue: string | number | boolean, currentIndex: number, array: (string | number | boolean)[]) => U, initialValue: U): U; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^
 
diff --git a/tests/baselines/reference/restPropertyWithBindingPattern.types b/tests/baselines/reference/restPropertyWithBindingPattern.types
index 50fdd835addfa..255e6f4f37018 100644
--- a/tests/baselines/reference/restPropertyWithBindingPattern.types
+++ b/tests/baselines/reference/restPropertyWithBindingPattern.types
@@ -32,8 +32,8 @@
 >               : ^^
 >{...[]} = {} : {}
 >             : ^^
->{...[]} : { [n: number]: never; length: 0; toString(): string; toLocaleString(): string; pop(): never | undefined; push(...items: never[]): number; concat(...items: ConcatArray<never>[]): never[]; concat(...items: ConcatArray<never>[]): never[]; join(separator?: string): string; reverse(): never[]; shift(): never | undefined; slice(start?: number, end?: number): never[]; sort(compareFn?: (a: never, b: never) => number): []; splice(start: number, deleteCount?: number): never[]; splice(start: number, deleteCount: number, ...items: never[]): never[]; unshift(...items: never[]): number; indexOf(searchElement: never, fromIndex?: number): number; lastIndexOf(searchElement: never, fromIndex?: number): number; every<S extends never>(predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; some(predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: never, index: number, array: never[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any): U[]; filter<S extends never>(predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): never[]; reduce(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never): never; reduce(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never, initialValue: never): never; reduce<U>(callbackfn: (previousValue: U, currentValue: never, currentIndex: number, array: never[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never): never; reduceRight(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never, initialValue: never): never; reduceRight<U>(callbackfn: (previousValue: U, currentValue: never, currentIndex: number, array: never[]) => U, initialValue: U): U; }
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^            ^^^^^^^^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^            ^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^  ^^^^^^^         ^^^^ ^^^^^^^^^ ^^^^^^^^^^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^  ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^     ^^^^^^^^^^^^      ^^^^^^^^^^             ^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^  ^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^            ^^^^^^^^^^
+>{...[]} : { [n: number]: never; length: 0; toString(): string; toLocaleString(): string; pop(): never; push(...items: never[]): number; concat(...items: ConcatArray<never>[]): never[]; concat(...items: ConcatArray<never>[]): never[]; join(separator?: string): string; reverse(): never[]; shift(): never; slice(start?: number, end?: number): never[]; sort(compareFn?: (a: never, b: never) => number): []; splice(start: number, deleteCount?: number): never[]; splice(start: number, deleteCount: number, ...items: never[]): never[]; unshift(...items: never[]): number; indexOf(searchElement: never, fromIndex?: number): number; lastIndexOf(searchElement: never, fromIndex?: number): number; every<S extends never>(predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; some(predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: never, index: number, array: never[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any): U[]; filter<S extends never>(predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): never[]; reduce(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never): never; reduce(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never, initialValue: never): never; reduce<U>(callbackfn: (previousValue: U, currentValue: never, currentIndex: number, array: never[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never): never; reduceRight(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never, initialValue: never): never; reduceRight<U>(callbackfn: (previousValue: U, currentValue: never, currentIndex: number, array: never[]) => U, initialValue: U): U; }
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^ ^^^^^^^^^^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^      ^^^^^^^^^^             ^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^            ^^^^^^^^^^
 >[] : []
 >   : ^^
 >{} : {}
@@ -44,8 +44,8 @@
 >                 : ^^
 >{...([])} = {} : {}
 >               : ^^
->{...([])} : { [n: number]: never; length: 0; toString(): string; toLocaleString(): string; pop(): never | undefined; push(...items: never[]): number; concat(...items: ConcatArray<never>[]): never[]; concat(...items: ConcatArray<never>[]): never[]; join(separator?: string): string; reverse(): never[]; shift(): never | undefined; slice(start?: number, end?: number): never[]; sort(compareFn?: (a: never, b: never) => number): []; splice(start: number, deleteCount?: number): never[]; splice(start: number, deleteCount: number, ...items: never[]): never[]; unshift(...items: never[]): number; indexOf(searchElement: never, fromIndex?: number): number; lastIndexOf(searchElement: never, fromIndex?: number): number; every<S extends never>(predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; some(predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: never, index: number, array: never[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any): U[]; filter<S extends never>(predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): never[]; reduce(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never): never; reduce(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never, initialValue: never): never; reduce<U>(callbackfn: (previousValue: U, currentValue: never, currentIndex: number, array: never[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never): never; reduceRight(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never, initialValue: never): never; reduceRight<U>(callbackfn: (previousValue: U, currentValue: never, currentIndex: number, array: never[]) => U, initialValue: U): U; }
->          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^            ^^^^^^^^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^            ^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^  ^^^^^^^         ^^^^ ^^^^^^^^^ ^^^^^^^^^^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^  ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^     ^^^^^^^^^^^^      ^^^^^^^^^^             ^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^  ^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^            ^^^^^^^^^^
+>{...([])} : { [n: number]: never; length: 0; toString(): string; toLocaleString(): string; pop(): never; push(...items: never[]): number; concat(...items: ConcatArray<never>[]): never[]; concat(...items: ConcatArray<never>[]): never[]; join(separator?: string): string; reverse(): never[]; shift(): never; slice(start?: number, end?: number): never[]; sort(compareFn?: (a: never, b: never) => number): []; splice(start: number, deleteCount?: number): never[]; splice(start: number, deleteCount: number, ...items: never[]): never[]; unshift(...items: never[]): number; indexOf(searchElement: never, fromIndex?: number): number; lastIndexOf(searchElement: never, fromIndex?: number): number; every<S extends never>(predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; some(predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: never, index: number, array: never[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: never, index: number, array: never[]) => U, thisArg?: any): U[]; filter<S extends never>(predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): never[]; reduce(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never): never; reduce(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never, initialValue: never): never; reduce<U>(callbackfn: (previousValue: U, currentValue: never, currentIndex: number, array: never[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never): never; reduceRight(callbackfn: (previousValue: never, currentValue: never, currentIndex: number, array: never[]) => never, initialValue: never): never; reduceRight<U>(callbackfn: (previousValue: U, currentValue: never, currentIndex: number, array: never[]) => U, initialValue: U): U; }
+>          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^ ^^^^^^^^^^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^      ^^^^^^^^^^             ^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^            ^^^^^^^^^^
 >([]) : []
 >     : ^^
 >[] : []
diff --git a/tests/baselines/reference/setMethods.types b/tests/baselines/reference/setMethods.types
index 05d6233c2c9f3..b588f6acd14bb 100644
--- a/tests/baselines/reference/setMethods.types
+++ b/tests/baselines/reference/setMethods.types
@@ -91,11 +91,11 @@ numberSet.union([]);
 >numberSet.union([]) : Set<unknown>
 >                    : ^^^^^^^^^^^^
 >numberSet.union : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >union : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->      : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>      : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 
@@ -103,11 +103,11 @@ numberSet.union(new Set);
 >numberSet.union(new Set) : Set<unknown>
 >                         : ^^^^^^^^^^^^
 >numberSet.union : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >union : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->      : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>      : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >new Set : Set<unknown>
 >        : ^^^^^^^^^^^^
 >Set : SetConstructor
@@ -117,11 +117,11 @@ numberSet.union(stringSet);
 >numberSet.union(stringSet) : Set<string | number>
 >                           : ^^^^^^^^^^^^^^^^^^^^
 >numberSet.union : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >union : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->      : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>      : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >stringSet : Set<string>
 >          : ^^^^^^^^^^^
 
@@ -129,11 +129,11 @@ numberSet.union(numberMap);
 >numberSet.union(numberMap) : Set<number>
 >                           : ^^^^^^^^^^^
 >numberSet.union : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >union : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->      : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>      : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberMap : Map<number, {}>
 >          : ^^^^^^^^^^^^^^^
 
@@ -141,11 +141,11 @@ numberSet.union(numberSetLike);
 >numberSet.union(numberSetLike) : Set<any>
 >                               : ^^^^^^^^
 >numberSet.union : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >union : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->      : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>      : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSetLike : { size: number; keys(): Generator<number, void, unknown>; has(x: any): boolean; }
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
 
@@ -153,11 +153,11 @@ numberSet.intersection([]);
 >numberSet.intersection([]) : Set<number>
 >                           : ^^^^^^^^^^^
 >numberSet.intersection : <U>(other: ReadonlySetLike<U>) => Set<number & U>
->                       : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                       : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >intersection : <U>(other: ReadonlySetLike<U>) => Set<number & U>
->             : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>             : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 
@@ -165,11 +165,11 @@ numberSet.intersection(new Set);
 >numberSet.intersection(new Set) : Set<number>
 >                                : ^^^^^^^^^^^
 >numberSet.intersection : <U>(other: ReadonlySetLike<U>) => Set<number & U>
->                       : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                       : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >intersection : <U>(other: ReadonlySetLike<U>) => Set<number & U>
->             : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>             : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >new Set : Set<unknown>
 >        : ^^^^^^^^^^^^
 >Set : SetConstructor
@@ -179,11 +179,11 @@ numberSet.intersection(stringSet);
 >numberSet.intersection(stringSet) : Set<never>
 >                                  : ^^^^^^^^^^
 >numberSet.intersection : <U>(other: ReadonlySetLike<U>) => Set<number & U>
->                       : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                       : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >intersection : <U>(other: ReadonlySetLike<U>) => Set<number & U>
->             : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>             : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >stringSet : Set<string>
 >          : ^^^^^^^^^^^
 
@@ -191,11 +191,11 @@ numberSet.intersection(numberMap);
 >numberSet.intersection(numberMap) : Set<number>
 >                                  : ^^^^^^^^^^^
 >numberSet.intersection : <U>(other: ReadonlySetLike<U>) => Set<number & U>
->                       : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                       : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >intersection : <U>(other: ReadonlySetLike<U>) => Set<number & U>
->             : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>             : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberMap : Map<number, {}>
 >          : ^^^^^^^^^^^^^^^
 
@@ -203,11 +203,11 @@ numberSet.intersection(numberSetLike);
 >numberSet.intersection(numberSetLike) : Set<any>
 >                                      : ^^^^^^^^
 >numberSet.intersection : <U>(other: ReadonlySetLike<U>) => Set<number & U>
->                       : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                       : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >intersection : <U>(other: ReadonlySetLike<U>) => Set<number & U>
->             : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>             : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSetLike : { size: number; keys(): Generator<number, void, unknown>; has(x: any): boolean; }
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
 
@@ -215,11 +215,11 @@ numberSet.difference([]);
 >numberSet.difference([]) : Set<number>
 >                         : ^^^^^^^^^^^
 >numberSet.difference : <U>(other: ReadonlySetLike<U>) => Set<number>
->                     : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^ 
+>                     : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >difference : <U>(other: ReadonlySetLike<U>) => Set<number>
->           : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^ 
+>           : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 
@@ -227,11 +227,11 @@ numberSet.difference(new Set);
 >numberSet.difference(new Set) : Set<number>
 >                              : ^^^^^^^^^^^
 >numberSet.difference : <U>(other: ReadonlySetLike<U>) => Set<number>
->                     : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^ 
+>                     : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >difference : <U>(other: ReadonlySetLike<U>) => Set<number>
->           : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^ 
+>           : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >new Set : Set<unknown>
 >        : ^^^^^^^^^^^^
 >Set : SetConstructor
@@ -241,11 +241,11 @@ numberSet.difference(stringSet);
 >numberSet.difference(stringSet) : Set<number>
 >                                : ^^^^^^^^^^^
 >numberSet.difference : <U>(other: ReadonlySetLike<U>) => Set<number>
->                     : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^ 
+>                     : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >difference : <U>(other: ReadonlySetLike<U>) => Set<number>
->           : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^ 
+>           : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >stringSet : Set<string>
 >          : ^^^^^^^^^^^
 
@@ -253,11 +253,11 @@ numberSet.difference(numberMap);
 >numberSet.difference(numberMap) : Set<number>
 >                                : ^^^^^^^^^^^
 >numberSet.difference : <U>(other: ReadonlySetLike<U>) => Set<number>
->                     : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^ 
+>                     : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >difference : <U>(other: ReadonlySetLike<U>) => Set<number>
->           : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^ 
+>           : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberMap : Map<number, {}>
 >          : ^^^^^^^^^^^^^^^
 
@@ -265,11 +265,11 @@ numberSet.difference(numberSetLike);
 >numberSet.difference(numberSetLike) : Set<number>
 >                                    : ^^^^^^^^^^^
 >numberSet.difference : <U>(other: ReadonlySetLike<U>) => Set<number>
->                     : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^ 
+>                     : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >difference : <U>(other: ReadonlySetLike<U>) => Set<number>
->           : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^ 
+>           : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSetLike : { size: number; keys(): Generator<number, void, unknown>; has(x: any): boolean; }
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
 
@@ -277,11 +277,11 @@ numberSet.symmetricDifference([]);
 >numberSet.symmetricDifference([]) : Set<unknown>
 >                                  : ^^^^^^^^^^^^
 >numberSet.symmetricDifference : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                              : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                              : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >symmetricDifference : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                    : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                    : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 
@@ -289,11 +289,11 @@ numberSet.symmetricDifference(new Set);
 >numberSet.symmetricDifference(new Set) : Set<unknown>
 >                                       : ^^^^^^^^^^^^
 >numberSet.symmetricDifference : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                              : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                              : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >symmetricDifference : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                    : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                    : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >new Set : Set<unknown>
 >        : ^^^^^^^^^^^^
 >Set : SetConstructor
@@ -303,11 +303,11 @@ numberSet.symmetricDifference(stringSet);
 >numberSet.symmetricDifference(stringSet) : Set<string | number>
 >                                         : ^^^^^^^^^^^^^^^^^^^^
 >numberSet.symmetricDifference : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                              : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                              : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >symmetricDifference : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                    : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                    : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >stringSet : Set<string>
 >          : ^^^^^^^^^^^
 
@@ -315,11 +315,11 @@ numberSet.symmetricDifference(numberMap);
 >numberSet.symmetricDifference(numberMap) : Set<number>
 >                                         : ^^^^^^^^^^^
 >numberSet.symmetricDifference : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                              : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                              : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >symmetricDifference : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                    : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                    : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberMap : Map<number, {}>
 >          : ^^^^^^^^^^^^^^^
 
@@ -327,11 +327,11 @@ numberSet.symmetricDifference(numberSetLike);
 >numberSet.symmetricDifference(numberSetLike) : Set<any>
 >                                             : ^^^^^^^^
 >numberSet.symmetricDifference : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                              : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                              : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSet : Set<number>
 >          : ^^^^^^^^^^^
 >symmetricDifference : <U>(other: ReadonlySetLike<U>) => Set<number | U>
->                    : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^   ^ 
+>                    : ^ ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >numberSetLike : { size: number; keys(): Generator<number, void, unknown>; has(x: any): boolean; }
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types
index b02cf6635acfe..2f057e02b8896 100644
--- a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types
+++ b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.types
@@ -5,21 +5,21 @@
 >[].map(() => [].map(p => ({ X: p }))) : { X: any; }[][]
 >                                      : ^^^^^^^^^^^^^^^
 >[].map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
->       : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>       : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 >map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >() => [].map(p => ({ X: p })) : () => { X: any; }[]
 >                              : ^^^^^^^^^^^^^^^^^^^
 >[].map(p => ({ X: p })) : { X: any; }[]
 >                        : ^^^^^^^^^^^^^
 >[].map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
->       : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>       : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 >map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >p => ({ X: p }) : (p: any) => { X: any; }
 >                : ^ ^^^^^^^^^^^^^^^^^^^^^
 >p : any
diff --git a/tests/baselines/reference/sliceResultCast.types b/tests/baselines/reference/sliceResultCast.types
index 95a357be636bc..20df45adcf6b9 100644
--- a/tests/baselines/reference/sliceResultCast.types
+++ b/tests/baselines/reference/sliceResultCast.types
@@ -11,11 +11,11 @@ x.slice(1) as readonly string[];
 >x.slice(1) : (string | number)[]
 >           : ^^^^^^^^^^^^^^^^^^^
 >x.slice : ((start?: number, end?: number) => (string | number)[]) | ((start?: number, end?: number) => (string | number)[])
->        : ^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^  ^
+>        : ^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : [number, string] | [number, string, string]
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >slice : ((start?: number, end?: number) => (string | number)[]) | ((start?: number, end?: number) => (string | number)[])
->      : ^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^  ^
+>      : ^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^
 >1 : 1
 >  : ^
 
diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types
index 9b8c226b4a2a4..64e8b34475784 100644
--- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.types
+++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.types
@@ -31,11 +31,11 @@ function foo() {
 >series2.map(seriesExtent) : any[]
 >                          : ^^^^^
 >series2.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->            : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>            : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >series2 : number[]
 >        : ^^^^^^^^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >seriesExtent : (series: any) => any
 >             : ^      ^^^^^^^^^^^^^
 
@@ -49,7 +49,7 @@ var keyExtent2: any[] = series.data.map(function (d: string) { return d; });
 >series.data.map(function (d: string) { return d; }) : string[]
 >                                                    : ^^^^^^^^
 >series.data.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->                : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >series.data : string[]
 >            : ^^^^^^^^
 >series : Series
@@ -57,7 +57,7 @@ var keyExtent2: any[] = series.data.map(function (d: string) { return d; });
 >data : string[]
 >     : ^^^^^^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >function (d: string) { return d; } : (d: string) => string
 >                                   : ^ ^^      ^^^^^^^^^^^
 >d : string
diff --git a/tests/baselines/reference/spreadInvalidArgumentType.types b/tests/baselines/reference/spreadInvalidArgumentType.types
index 5b4fbca01a421..d1d64b92fee1b 100644
--- a/tests/baselines/reference/spreadInvalidArgumentType.types
+++ b/tests/baselines/reference/spreadInvalidArgumentType.types
@@ -105,10 +105,10 @@ function f<T extends { b: string }>(p1: T, p2: T[]) {
 >   : ^
 
     var o2 = { ...p2 };  // OK
->o2 : { [x: number]: T; length: number; toString(): string; toLocaleString(): string; pop(): T | undefined; push(...items: T[]): number; concat(...items: ConcatArray<T>[]): T[]; concat(...items: (T | ConcatArray<T>)[]): T[]; join(separator?: string): string; reverse(): T[]; shift(): T | undefined; slice(start?: number, end?: number): T[]; sort(compareFn?: (a: T, b: T) => number): T[]; splice(start: number, deleteCount?: number): T[]; splice(start: number, deleteCount: number, ...items: T[]): T[]; unshift(...items: T[]): number; indexOf(searchElement: T, fromIndex?: number): number; lastIndexOf(searchElement: T, fromIndex?: number): number; every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^            ^^^^^^^^^^     ^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^  ^^^^^^^^^^^^            ^^^^^^^^     ^^^      ^^   ^^^      ^^^^  ^^^^^^^         ^^^^ ^^^^^ ^^^^^^^^      ^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^  ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^  ^^^^^^^^^^^^^     ^^^^^^^^      ^^^^^^^^^^             ^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^^  ^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^
->{ ...p2 } : { [n: number]: T; length: number; toString(): string; toLocaleString(): string; pop(): T | undefined; push(...items: T[]): number; concat(...items: ConcatArray<T>[]): T[]; concat(...items: (T | ConcatArray<T>)[]): T[]; join(separator?: string): string; reverse(): T[]; shift(): T | undefined; slice(start?: number, end?: number): T[]; sort(compareFn?: (a: T, b: T) => number): T[]; splice(start: number, deleteCount?: number): T[]; splice(start: number, deleteCount: number, ...items: T[]): T[]; unshift(...items: T[]): number; indexOf(searchElement: T, fromIndex?: number): number; lastIndexOf(searchElement: T, fromIndex?: number): number; every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
->          : ^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^            ^^^^^^^^^^     ^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^  ^^^^^^^^^^^^            ^^^^^^^^     ^^^      ^^   ^^^      ^^^^  ^^^^^^^         ^^^^ ^^^^^ ^^^^^^^^      ^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^  ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^  ^^^^^^^^^^^^^     ^^^^^^^^      ^^^^^^^^^^             ^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^^  ^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^
+>o2 : { [x: number]: T; length: number; toString(): string; toLocaleString(): string; pop(): T; push(...items: T[]): number; concat(...items: ConcatArray<T>[]): T[]; concat(...items: (T | ConcatArray<T>)[]): T[]; join(separator?: string): string; reverse(): T[]; shift(): T; slice(start?: number, end?: number): T[]; sort(compareFn?: (a: T, b: T) => number): T[]; splice(start: number, deleteCount?: number): T[]; splice(start: number, deleteCount: number, ...items: T[]): T[]; unshift(...items: T[]): number; indexOf(searchElement: T, fromIndex?: number): number; lastIndexOf(searchElement: T, fromIndex?: number): number; every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^         ^^^^ ^^^^^ ^^^^^^^^      ^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^      ^^^^^^^^^^             ^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^
+>{ ...p2 } : { [n: number]: T; length: number; toString(): string; toLocaleString(): string; pop(): T; push(...items: T[]): number; concat(...items: ConcatArray<T>[]): T[]; concat(...items: (T | ConcatArray<T>)[]): T[]; join(separator?: string): string; reverse(): T[]; shift(): T; slice(start?: number, end?: number): T[]; sort(compareFn?: (a: T, b: T) => number): T[]; splice(start: number, deleteCount?: number): T[]; splice(start: number, deleteCount: number, ...items: T[]): T[]; unshift(...items: T[]): number; indexOf(searchElement: T, fromIndex?: number): number; lastIndexOf(searchElement: T, fromIndex?: number): number; every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[]; every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
+>          : ^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^      ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^         ^^^^ ^^^^^ ^^^^^^^^      ^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^      ^^^^^^^^^^             ^^^^^         ^^^      ^^^      ^^^^^^^^^^^^^^             ^^^^^         ^^^      ^^^      ^^^^^^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^    ^^       ^^^   ^^^    ^^^^^^ ^^          ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^         ^^^     ^^^^^     ^^      ^^     ^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^            ^^      ^^     ^^^^^^^^^^^^^            ^^^^^^^^^^
 >p2 : T[]
 >   : ^^^
 
diff --git a/tests/baselines/reference/spreadNonObject1.types b/tests/baselines/reference/spreadNonObject1.types
index 45e671948f523..9b3bb1b1f7dbe 100644
--- a/tests/baselines/reference/spreadNonObject1.types
+++ b/tests/baselines/reference/spreadNonObject1.types
@@ -19,7 +19,7 @@ const b = {
 >(["4"] as S[]).map(function (s) {    const a = { ...s, y: 6 };  }) : void[]
 >                                                                   : ^^^^^^
 >(["4"] as S[]).map : <U>(callbackfn: (value: `${number}`, index: number, array: `${number}`[]) => U, thisArg?: any) => U[]
->                   : ^ ^^          ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                   : ^ ^^          ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(["4"] as S[]) : `${number}`[]
 >               : ^^^^^^^^^^^^^
 >["4"] as S[] : `${number}`[]
@@ -29,7 +29,7 @@ const b = {
 >"4" : "4"
 >    : ^^^
 >map : <U>(callbackfn: (value: `${number}`, index: number, array: `${number}`[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >function (s) {    const a = { ...s, y: 6 };  } : (s: `${number}`) => void
 >                                               : ^ ^^^^^^^^^^^^^^^^^^^^^^
 >s : `${number}`
diff --git a/tests/baselines/reference/staticAnonymousTypeNotReferencingTypeParameter.types b/tests/baselines/reference/staticAnonymousTypeNotReferencingTypeParameter.types
index 04ef6df96e1e8..0697ec2a909ef 100644
--- a/tests/baselines/reference/staticAnonymousTypeNotReferencingTypeParameter.types
+++ b/tests/baselines/reference/staticAnonymousTypeNotReferencingTypeParameter.types
@@ -54,11 +54,11 @@ class ListWrapper2 {
 >array.slice(0) : T[]
 >               : ^^^
 >array.slice : (start?: number, end?: number) => T[]
->            : ^     ^^^      ^^   ^^^      ^^^^^^  
+>            : ^     ^^^      ^^   ^^^      ^^^^^^^^
 >array : T[]
 >      : ^^^
 >slice : (start?: number, end?: number) => T[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^
 >0 : 0
 >  : ^
 
@@ -234,11 +234,11 @@ class ListWrapper {
 >array.slice(0) : T[]
 >               : ^^^
 >array.slice : (start?: number, end?: number) => T[]
->            : ^     ^^^      ^^   ^^^      ^^^^^^  
+>            : ^     ^^^      ^^   ^^^      ^^^^^^^^
 >array : T[]
 >      : ^^^
 >slice : (start?: number, end?: number) => T[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^
 >0 : 0
 >  : ^
 
@@ -493,11 +493,11 @@ class ListWrapper {
 >a.reverse() : T[]
 >            : ^^^
 >a.reverse : () => T[]
->          : ^^^^^^^  
+>          : ^^^^^^^^^
 >a : T[]
 >  : ^^^
 >reverse : () => T[]
->        : ^^^^^^^  
+>        : ^^^^^^^^^
 >a : T[]
 >  : ^^^
   }
@@ -515,11 +515,11 @@ class ListWrapper {
 >a.concat(b) : any[]
 >            : ^^^^^
 >a.concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
->         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^  ^^^
+>         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^
 >a : any[]
 >  : ^^^^^
 >concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^
 >b : any[]
 >  : ^^^^^
 
@@ -539,11 +539,11 @@ class ListWrapper {
 >list.splice(index, 0, value) : T[]
 >                             : ^^^
 >list.splice : { (start: number, deleteCount?: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
->            : ^^^     ^^      ^^           ^^^      ^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^  ^^^
+>            : ^^^     ^^      ^^           ^^^      ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^
 >list : T[]
 >     : ^^^
 >splice : { (start: number, deleteCount?: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
->       : ^^^     ^^      ^^           ^^^      ^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^  ^^^
+>       : ^^^     ^^      ^^           ^^^      ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^
 >index : number
 >      : ^^^^^^
 >0 : 0
@@ -577,11 +577,11 @@ class ListWrapper {
 >list.splice(index, 1) : T[]
 >                      : ^^^
 >list.splice : { (start: number, deleteCount?: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
->            : ^^^     ^^      ^^           ^^^      ^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^  ^^^
+>            : ^^^     ^^      ^^           ^^^      ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^
 >list : T[]
 >     : ^^^
 >splice : { (start: number, deleteCount?: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
->       : ^^^     ^^      ^^           ^^^      ^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^  ^^^
+>       : ^^^     ^^      ^^           ^^^      ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^
 >index : number
 >      : ^^^^^^
 >1 : 1
@@ -645,11 +645,11 @@ class ListWrapper {
 >list.splice(index, 1) : T[]
 >                      : ^^^
 >list.splice : { (start: number, deleteCount?: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
->            : ^^^     ^^      ^^           ^^^      ^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^  ^^^
+>            : ^^^     ^^      ^^           ^^^      ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^
 >list : T[]
 >     : ^^^
 >splice : { (start: number, deleteCount?: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
->       : ^^^     ^^      ^^           ^^^      ^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^  ^^^
+>       : ^^^     ^^      ^^           ^^^      ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^
 >index : number
 >      : ^^^^^^
 >1 : 1
@@ -696,11 +696,11 @@ class ListWrapper {
 >list.splice(index, 1) : T[]
 >                      : ^^^
 >list.splice : { (start: number, deleteCount?: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
->            : ^^^     ^^      ^^           ^^^      ^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^  ^^^
+>            : ^^^     ^^      ^^           ^^^      ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^
 >list : T[]
 >     : ^^^
 >splice : { (start: number, deleteCount?: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
->       : ^^^     ^^      ^^           ^^^      ^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^  ^^^
+>       : ^^^     ^^      ^^           ^^^      ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^
 >index : number
 >      : ^^^^^^
 >1 : 1
@@ -888,11 +888,11 @@ class ListWrapper {
 >l.slice(from, to === null ? undefined : to) : T[]
 >                                            : ^^^
 >l.slice : (start?: number, end?: number) => T[]
->        : ^     ^^^      ^^   ^^^      ^^^^^^  
+>        : ^     ^^^      ^^   ^^^      ^^^^^^^^
 >l : T[]
 >  : ^^^
 >slice : (start?: number, end?: number) => T[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^
 >from : number
 >     : ^^^^^^
 >to === null ? undefined : to : number
@@ -922,11 +922,11 @@ class ListWrapper {
 >l.splice(from, length) : T[]
 >                       : ^^^
 >l.splice : { (start: number, deleteCount?: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
->         : ^^^     ^^      ^^           ^^^      ^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^  ^^^
+>         : ^^^     ^^      ^^           ^^^      ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^
 >l : T[]
 >  : ^^^
 >splice : { (start: number, deleteCount?: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
->       : ^^^     ^^      ^^           ^^^      ^^^^  ^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^  ^^^
+>       : ^^^     ^^      ^^           ^^^      ^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^
 >from : number
 >     : ^^^^^^
 >length : number
diff --git a/tests/baselines/reference/symbolProperty61.types b/tests/baselines/reference/symbolProperty61.types
index 81c46783d7f98..cc91c95e62988 100644
--- a/tests/baselines/reference/symbolProperty61.types
+++ b/tests/baselines/reference/symbolProperty61.types
@@ -100,7 +100,7 @@ function from<T>(obs: InteropObservable<T>) {
 >obs[Symbol.obs]() : { subscribe(next: (val: T) => void): void; }
 >                  : ^^^^^^^^^^^^    ^^^   ^^^^^^^^    ^^^    ^^^
 >obs[Symbol.obs] : () => { subscribe(next: (val: T) => void): void; }
->                : ^^^^^^                        ^                   
+>                : ^^^^^^^^^^^^^^^^^^    ^^^   ^^^^^^^^    ^^^    ^^^
 >obs : InteropObservable<T>
 >    : ^^^^^^^^^^^^^^^^^^^^
 >Symbol.obs : unique symbol
diff --git a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types
index b044842add20c..e56f972e46f73 100644
--- a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types
+++ b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types
@@ -16,13 +16,13 @@ import("package").then(({default: foo}) => foo(42));
 >import("package").then(({default: foo}) => foo(42)) : Promise<string>
 >                                                    : ^^^^^^^^^^^^^^^
 >import("package").then : <TResult1 = { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: { default: (x: number) => string; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                       : ^        ^^^^^^^^^^^^^^^ ^^      ^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^ ^^      ^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                       : ^        ^^^^^^^^^^^^^^^ ^^      ^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^ ^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >import("package") : Promise<{ default: (x: number) => string; }>
 >                  : ^^^^^^^^^^^^^^^^^^^^ ^^      ^^^^^      ^^^^
 >"package" : "package"
 >          : ^^^^^^^^^
 >then : <TResult1 = { default: (x: number) => string; }, TResult2 = never>(onfulfilled?: (value: { default: (x: number) => string; }) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^^^^ ^^      ^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^ ^^      ^^^^^      ^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^^^^ ^^      ^^^^^      ^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^ ^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >({default: foo}) => foo(42) : ({ default: foo }: { default: (x: number) => string; }) => string
 >                            : ^                ^^^^^^^^^^^^^^ ^^      ^^^^^      ^^^^^^^^^^^^^^
 >default : any
diff --git a/tests/baselines/reference/templateLiteralTypes4.types b/tests/baselines/reference/templateLiteralTypes4.types
index af3db82ba73cc..ef54a53c3efc2 100644
--- a/tests/baselines/reference/templateLiteralTypes4.types
+++ b/tests/baselines/reference/templateLiteralTypes4.types
@@ -679,11 +679,11 @@ p.getIndex(0); // ok, 0 is a valid index
 >p.getIndex(0) : number
 >              : ^^^^^^
 >p.getIndex : <I extends 0 | 1>(index: I) => FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>
->           : ^ ^^^^^^^^^^^^^^^^     ^^^^^^^^                  ^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^                           
+>           : ^ ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Point
 >  : ^^^^^
 >getIndex : <I extends 0 | 1>(index: I) => FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>
->         : ^ ^^^^^^^^^^^^^^^^     ^^^^^^^^                  ^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^                           
+>         : ^ ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 
@@ -691,11 +691,11 @@ p.getIndex(1); // ok, 1 is a valid index
 >p.getIndex(1) : number
 >              : ^^^^^^
 >p.getIndex : <I extends 0 | 1>(index: I) => FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>
->           : ^ ^^^^^^^^^^^^^^^^     ^^^^^^^^                  ^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^                           
+>           : ^ ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Point
 >  : ^^^^^
 >getIndex : <I extends 0 | 1>(index: I) => FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>
->         : ^ ^^^^^^^^^^^^^^^^     ^^^^^^^^                  ^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^                           
+>         : ^ ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >1 : 1
 >  : ^
 
@@ -703,11 +703,11 @@ p.getIndex(2); // error, 2 is not a valid index
 >p.getIndex(2) : number
 >              : ^^^^^^
 >p.getIndex : <I extends 0 | 1>(index: I) => FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>
->           : ^ ^^^^^^^^^^^^^^^^     ^^^^^^^^                  ^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^                           
+>           : ^ ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Point
 >  : ^^^^^
 >getIndex : <I extends 0 | 1>(index: I) => FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>
->         : ^ ^^^^^^^^^^^^^^^^     ^^^^^^^^                  ^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^                           
+>         : ^ ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^   ^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >2 : 2
 >  : ^
 
diff --git a/tests/baselines/reference/thisConditionalOnMethodReturnOfGenericInstance.types b/tests/baselines/reference/thisConditionalOnMethodReturnOfGenericInstance.types
index 54f42764aa8be..95bc7c26419a8 100644
--- a/tests/baselines/reference/thisConditionalOnMethodReturnOfGenericInstance.types
+++ b/tests/baselines/reference/thisConditionalOnMethodReturnOfGenericInstance.types
@@ -50,10 +50,10 @@ const y = x.method(); // usage flags `method` in `B` as circular and marks `y` a
 >  : ^^^^^^^^^^^^^^^^^^
 >x.method() : string | undefined
 >           : ^^^^^^^^^^^^^^^^^^
->x.method : () => string | (C<{}> extends C ? undefined : null)
->         : ^^^^^^          ^^^^^                              
+>x.method : () => string | undefined
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^
 >x : C<{}>
 >  : ^^^^^
->method : () => string | (C<{}> extends C ? undefined : null)
->       : ^^^^^^          ^^^^^                              
+>method : () => string | undefined
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/thisExpressionInCallExpressionWithTypeArguments.types b/tests/baselines/reference/thisExpressionInCallExpressionWithTypeArguments.types
index 79ee33e2fb5dc..546c0ade62b71 100644
--- a/tests/baselines/reference/thisExpressionInCallExpressionWithTypeArguments.types
+++ b/tests/baselines/reference/thisExpressionInCallExpressionWithTypeArguments.types
@@ -11,7 +11,7 @@ class C {
 >[1,2,3].map<any,any>((x) => { return this; }) : any[]
 >                                              : ^^^^^
 >[1,2,3].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->            : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>            : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1,2,3] : number[]
 >        : ^^^^^^^^
 >1 : 1
@@ -21,7 +21,7 @@ class C {
 >3 : 3
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(x) => { return this; } : (x: number) => this
 >                        : ^ ^^^^^^^^^^^^^^^^^
 >x : number
diff --git a/tests/baselines/reference/thisInFunctionCall.types b/tests/baselines/reference/thisInFunctionCall.types
index 003d54da50352..8a91a9f73e728 100644
--- a/tests/baselines/reference/thisInFunctionCall.types
+++ b/tests/baselines/reference/thisInFunctionCall.types
@@ -36,16 +36,16 @@ class Test {
     this.data.find(function (d) {
 >this.data.find(function (d) {      return d === this.data.length    }) : number
 >                                                                       : ^^^^^^
->this.data.find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }
->               : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>this.data.find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }
+>               : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >this.data : number[]
 >          : ^^^^^^^^
 >this : this
 >     : ^^^^
 >data : number[]
 >     : ^^^^^^^^
->find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }
->     : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }
+>     : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >function (d) {      return d === this.data.length    } : (d: number) => boolean
 >                                                       : ^ ^^^^^^^^^^^^^^^^^^^^
 >d : number
@@ -180,16 +180,16 @@ class Test {
     this.data.find(
 >this.data.find(    /** @this {Test} */    function (d) {      return d === this.data.length    }, this) : number
 >                                                                                                        : ^^^^^^
->this.data.find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }
->               : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>this.data.find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }
+>               : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >this.data : number[]
 >          : ^^^^^^^^
 >this : this
 >     : ^^^^
 >data : number[]
 >     : ^^^^^^^^
->find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }
->     : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }
+>     : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 
     /** @this {Test} */
     function (d) {
diff --git a/tests/baselines/reference/thisInFunctionCallJs.types b/tests/baselines/reference/thisInFunctionCallJs.types
index a2106eb559466..346eae49d383a 100644
--- a/tests/baselines/reference/thisInFunctionCallJs.types
+++ b/tests/baselines/reference/thisInFunctionCallJs.types
@@ -33,16 +33,16 @@ class Test {
         this.data.find(function (d) {
 >this.data.find(function (d) {            return d === this.data.length        }) : number
 >                                                                                 : ^^^^^^
->this.data.find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }
->               : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>this.data.find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }
+>               : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >this.data : number[]
 >          : ^^^^^^^^
 >this : this
 >     : ^^^^
 >data : number[]
 >     : ^^^^^^^^
->find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }
->     : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }
+>     : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >function (d) {            return d === this.data.length        } : (d: number) => boolean
 >                                                                 : ^ ^^^^^^^^^^^^^^^^^^^^
 >d : number
@@ -177,16 +177,16 @@ class Test {
         this.data.find(
 >this.data.find(        /** @this {Test} */        function (d) {            return d === this.data.length        }, this) : number
 >                                                                                                                          : ^^^^^^
->this.data.find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }
->               : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>this.data.find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }
+>               : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >this.data : number[]
 >          : ^^^^^^^^
 >this : this
 >     : ^^^^
 >data : number[]
 >     : ^^^^^^^^
->find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number | undefined; }
->     : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^            ^^^
+>find : { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }
+>     : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 
         /** @this {Test} */
         function (d) {
diff --git a/tests/baselines/reference/thisTypeInTuples.types b/tests/baselines/reference/thisTypeInTuples.types
index ea5de79797c63..4df23939db1f5 100644
--- a/tests/baselines/reference/thisTypeInTuples.types
+++ b/tests/baselines/reference/thisTypeInTuples.types
@@ -23,11 +23,11 @@ let a = t.slice();
 >t.slice() : [number, string]
 >          : ^^^^^^^^^^^^^^^^
 >t.slice : { (start?: number, end?: number): (string | number)[]; (): [number, string]; }
->        : ^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^
+>        : ^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >t : [number, string]
 >  : ^^^^^^^^^^^^^^^^
 >slice : { (start?: number, end?: number): (string | number)[]; (): [number, string]; }
->      : ^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^
+>      : ^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 let b = t.slice(1);
 >b : (string | number)[]
@@ -35,11 +35,11 @@ let b = t.slice(1);
 >t.slice(1) : (string | number)[]
 >           : ^^^^^^^^^^^^^^^^^^^
 >t.slice : { (start?: number, end?: number): (string | number)[]; (): [number, string]; }
->        : ^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^
+>        : ^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >t : [number, string]
 >  : ^^^^^^^^^^^^^^^^
 >slice : { (start?: number, end?: number): (string | number)[]; (): [number, string]; }
->      : ^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^
+>      : ^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >1 : 1
 >  : ^
 
@@ -49,11 +49,11 @@ let c = t.slice(0, 1);
 >t.slice(0, 1) : (string | number)[]
 >              : ^^^^^^^^^^^^^^^^^^^
 >t.slice : { (start?: number, end?: number): (string | number)[]; (): [number, string]; }
->        : ^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^
+>        : ^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >t : [number, string]
 >  : ^^^^^^^^^^^^^^^^
 >slice : { (start?: number, end?: number): (string | number)[]; (): [number, string]; }
->      : ^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^
+>      : ^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 >1 : 1
diff --git a/tests/baselines/reference/truthinessPromiseCoercion.types b/tests/baselines/reference/truthinessPromiseCoercion.types
index c92608e96ec96..595d1b72af1a1 100644
--- a/tests/baselines/reference/truthinessPromiseCoercion.types
+++ b/tests/baselines/reference/truthinessPromiseCoercion.types
@@ -119,11 +119,11 @@ async function g() {
 >p.then.length : number
 >              : ^^^^^^
 >p.then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->       : ^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>       : ^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : Promise<number>
 >  : ^^^^^^^^^^^^^^^
 >then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >length : number
 >       : ^^^^^^
 
@@ -240,13 +240,13 @@ async function i(): Promise<string> {
 >pf().then() : Promise<boolean>
 >            : ^^^^^^^^^^^^^^^^
 >pf().then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->          : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>          : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >pf() : Promise<boolean>
 >     : ^^^^^^^^^^^^^^^^
 >pf : () => Promise<boolean>
 >   : ^^^^^^                
 >then : <TResult1 = boolean, TResult2 = never>(onfulfilled?: ((value: boolean) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     }
     return "false";
 >"false" : "false"
diff --git a/tests/baselines/reference/tsxSpreadChildren.types b/tests/baselines/reference/tsxSpreadChildren.types
index e0fd03d4a0012..c60b95ace1470 100644
--- a/tests/baselines/reference/tsxSpreadChildren.types
+++ b/tests/baselines/reference/tsxSpreadChildren.types
@@ -80,11 +80,11 @@ function TodoList({ todos }: TodoListProps) {
 >todos.map(todo => <Todo key={todo.id} todo={todo.todo}/>) : JSX.Element[]
 >                                                          : ^^^^^^^^^^^^^
 >todos.map : <U>(callbackfn: (value: TodoProp, index: number, array: TodoProp[]) => U, thisArg?: any) => U[]
->          : ^ ^^          ^^^     ^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>          : ^ ^^          ^^^     ^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >todos : TodoProp[]
 >      : ^^^^^^^^^^
 >map : <U>(callbackfn: (value: TodoProp, index: number, array: TodoProp[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >todo => <Todo key={todo.id} todo={todo.todo}/> : (todo: TodoProp) => JSX.Element
 >                                               : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >todo : TodoProp
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types
index 942220666a10c..bdd54b8f033ec 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types
+++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.types
@@ -22,11 +22,11 @@ nodes.map(n => n.name);
 >nodes.map(n => n.name) : string[]
 >                       : ^^^^^^^^
 >nodes.map : <U>(callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any) => U[]
->          : ^ ^^          ^^^     ^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>          : ^ ^^          ^^^     ^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >nodes : TreeNode[]
 >      : ^^^^^^^^^^
 >map : <U>(callbackfn: (value: TreeNode, index: number, array: TreeNode[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >n => n.name : (n: TreeNode) => string
 >            : ^ ^^^^^^^^^^^^^^^^^^^^^
 >n : TreeNode
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types
index 3989519a2edba..132782c307aac 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types
+++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.types
@@ -35,11 +35,11 @@ nodes.map(n => n.name);
 >nodes.map(n => n.name) : string[]
 >                       : ^^^^^^^^
 >nodes.map : <U>(callbackfn: (value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg?: any) => U[]
->          : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>          : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >nodes : TreeNodeMiddleman[]
 >      : ^^^^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: TreeNodeMiddleman, index: number, array: TreeNodeMiddleman[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >n => n.name : (n: TreeNodeMiddleman) => string
 >            : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >n : TreeNodeMiddleman
diff --git a/tests/baselines/reference/typeFromJSInitializer.types b/tests/baselines/reference/typeFromJSInitializer.types
index 1e94db78b7dea..7c6828fc674df 100644
--- a/tests/baselines/reference/typeFromJSInitializer.types
+++ b/tests/baselines/reference/typeFromJSInitializer.types
@@ -423,11 +423,11 @@ const g = e.filter(isUndef);
 >e.filter(isUndef) : undefined[]
 >                  : ^^^^^^^^^^^
 >e.filter : { <S extends number | undefined>(predicate: (value: number | undefined, index: number, array: (number | undefined)[]) => value is S, thisArg?: any): S[]; (predicate: (value: number | undefined, index: number, array: (number | undefined)[]) => unknown, thisArg?: any): (number | undefined)[]; }
->         : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>         : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >e : (number | undefined)[]
 >  : ^^^^^^^^^^^^^^^^^^^^^^
 >filter : { <S extends number | undefined>(predicate: (value: number | undefined, index: number, array: (number | undefined)[]) => value is S, thisArg?: any): S[]; (predicate: (value: number | undefined, index: number, array: (number | undefined)[]) => unknown, thisArg?: any): (number | undefined)[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >isUndef : (v: unknown) => v is undefined
 >        : ^ ^^       ^^^^^              
 
diff --git a/tests/baselines/reference/typeInferenceTypePredicate2.types b/tests/baselines/reference/typeInferenceTypePredicate2.types
index abe3809d15780..11fa42a2ff435 100644
--- a/tests/baselines/reference/typeInferenceTypePredicate2.types
+++ b/tests/baselines/reference/typeInferenceTypePredicate2.types
@@ -5,11 +5,11 @@
 >[true, true, false, null]    .filter((thing): thing is boolean => thing !== null)    .map(thing => thing.toString()) : string[]
 >                                                                                                                     : ^^^^^^^^
 >[true, true, false, null]    .filter((thing): thing is boolean => thing !== null)    .map : <U>(callbackfn: (value: boolean, index: number, array: boolean[]) => U, thisArg?: any) => U[]
->                                                                                          : ^ ^^          ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                                                                                          : ^ ^^          ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[true, true, false, null]    .filter((thing): thing is boolean => thing !== null) : boolean[]
 >                                                                                  : ^^^^^^^^^
 >[true, true, false, null]    .filter : { <S extends boolean>(predicate: (value: boolean, index: number, array: boolean[]) => value is S, thisArg?: any): S[]; (predicate: (value: boolean, index: number, array: boolean[]) => unknown, thisArg?: any): boolean[]; }
->                                     : ^^^ ^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^  ^^^
+>                                     : ^^^ ^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^
 >[true, true, false, null] : boolean[]
 >                          : ^^^^^^^^^
 >true : true
@@ -21,7 +21,7 @@
 
     .filter((thing): thing is boolean => thing !== null)
 >filter : { <S extends boolean>(predicate: (value: boolean, index: number, array: boolean[]) => value is S, thisArg?: any): S[]; (predicate: (value: boolean, index: number, array: boolean[]) => unknown, thisArg?: any): boolean[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^
 >(thing): thing is boolean => thing !== null : (thing: boolean) => thing is boolean
 >                                            : ^     ^^^^^^^^^^^^^^                
 >thing : boolean
@@ -33,7 +33,7 @@
 
     .map(thing => thing.toString());
 >map : <U>(callbackfn: (value: boolean, index: number, array: boolean[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >thing => thing.toString() : (thing: boolean) => string
 >                          : ^     ^^^^^^^^^^^^^^^^^^^^
 >thing : boolean
diff --git a/tests/baselines/reference/typeParameterLeak.types b/tests/baselines/reference/typeParameterLeak.types
index 23b5264b75cc5..3700dc7d26e32 100644
--- a/tests/baselines/reference/typeParameterLeak.types
+++ b/tests/baselines/reference/typeParameterLeak.types
@@ -33,7 +33,7 @@ interface BoxFactory<A> {
 
 declare const f: BoxFactoryFactory<BoxTypes>;
 >f : ((arg: { x: string; }) => BoxFactory<Box<{ x: string; }>> | undefined) | ((arg: { y: string; }) => BoxFactory<Box<{ y: string; }>> | undefined)
->  : ^^   ^^^^^^^      ^^^^^^^^           ^^^^^^^^^      ^^^^             ^^^^^^   ^^^^^^^      ^^^^^^^^           ^^^^^^^^^      ^^^^             ^
+>  : ^^   ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^
 
 const b = f({ x: "", y: "" })?.getBox();
 >b : Box<{ x: string; }> | Box<{ y: string; }> | undefined
@@ -45,7 +45,7 @@ const b = f({ x: "", y: "" })?.getBox();
 >f({ x: "", y: "" }) : BoxFactory<Box<{ x: string; }>> | BoxFactory<Box<{ y: string; }>> | undefined
 >                    : ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^
 >f : ((arg: { x: string; }) => BoxFactory<Box<{ x: string; }>> | undefined) | ((arg: { y: string; }) => BoxFactory<Box<{ y: string; }>> | undefined)
->  : ^^   ^^^^^^^      ^^^^^^^^           ^^^^^^^^^      ^^^^             ^^^^^^   ^^^^^^^      ^^^^^^^^           ^^^^^^^^^      ^^^^             ^
+>  : ^^   ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^
 >{ x: "", y: "" } : { x: string; y: string; }
 >                 : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : string
diff --git a/tests/baselines/reference/typePredicateFreshLiteralWidening.types b/tests/baselines/reference/typePredicateFreshLiteralWidening.types
index bba0f46830243..98bba0521eea0 100644
--- a/tests/baselines/reference/typePredicateFreshLiteralWidening.types
+++ b/tests/baselines/reference/typePredicateFreshLiteralWidening.types
@@ -112,11 +112,11 @@ const filteredValues2 = values2.filter(isNotNull);
 >values2.filter(isNotNull) : ("1" | "2")[]
 >                          : ^^^^^^^^^^^^^
 >values2.filter : { <S extends "1" | "2" | null>(predicate: (value: "1" | "2" | null, index: number, array: ("1" | "2" | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: "1" | "2" | null, index: number, array: ("1" | "2" | null)[]) => unknown, thisArg?: any): ("1" | "2" | null)[]; }
->               : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^  ^^^
+>               : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >values2 : ("1" | "2" | null)[]
 >        : ^^^^^^^^^^^^^^^^^^^^
 >filter : { <S extends "1" | "2" | null>(predicate: (value: "1" | "2" | null, index: number, array: ("1" | "2" | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: "1" | "2" | null, index: number, array: ("1" | "2" | null)[]) => unknown, thisArg?: any): ("1" | "2" | null)[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >isNotNull : <T>(value: T | null) => value is T
 >          : ^ ^^     ^^        ^^^^^          
 
@@ -126,7 +126,7 @@ const values1 = [item1, item2, item3].map(item => item.value);
 >[item1, item2, item3].map(item => item.value) : ("1" | "2" | null)[]
 >                                              : ^^^^^^^^^^^^^^^^^^^^
 >[item1, item2, item3].map : <U>(callbackfn: (value: { value: "1"; } | { value: "2"; } | { value: null; }, index: number, array: ({ value: "1"; } | { value: "2"; } | { value: null; })[]) => U, thisArg?: any) => U[]
->                          : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                          : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[item1, item2, item3] : ({ value: "1"; } | { value: "2"; } | { value: null; })[]
 >                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >item1 : { value: "1"; }
@@ -136,7 +136,7 @@ const values1 = [item1, item2, item3].map(item => item.value);
 >item3 : { value: null; }
 >      : ^^^^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: { value: "1"; } | { value: "2"; } | { value: null; }, index: number, array: ({ value: "1"; } | { value: "2"; } | { value: null; })[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >item => item.value : (item: { value: "1"; } | { value: "2"; } | { value: null; }) => "1" | "2" | null
 >                   : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >item : { value: "1"; } | { value: "2"; } | { value: null; }
@@ -154,11 +154,11 @@ const filteredValues1 = values1.filter(isNotNull);
 >values1.filter(isNotNull) : ("1" | "2")[]
 >                          : ^^^^^^^^^^^^^
 >values1.filter : { <S extends "1" | "2" | null>(predicate: (value: "1" | "2" | null, index: number, array: ("1" | "2" | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: "1" | "2" | null, index: number, array: ("1" | "2" | null)[]) => unknown, thisArg?: any): ("1" | "2" | null)[]; }
->               : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^  ^^^
+>               : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >values1 : ("1" | "2" | null)[]
 >        : ^^^^^^^^^^^^^^^^^^^^
 >filter : { <S extends "1" | "2" | null>(predicate: (value: "1" | "2" | null, index: number, array: ("1" | "2" | null)[]) => value is S, thisArg?: any): S[]; (predicate: (value: "1" | "2" | null, index: number, array: ("1" | "2" | null)[]) => unknown, thisArg?: any): ("1" | "2" | null)[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >isNotNull : <T>(value: T | null) => value is T
 >          : ^ ^^     ^^        ^^^^^          
 
diff --git a/tests/baselines/reference/typePredicateTopLevelTypeParameter.types b/tests/baselines/reference/typePredicateTopLevelTypeParameter.types
index 711ba2a9ff5b4..4de646b269f15 100644
--- a/tests/baselines/reference/typePredicateTopLevelTypeParameter.types
+++ b/tests/baselines/reference/typePredicateTopLevelTypeParameter.types
@@ -30,7 +30,7 @@ const admins = ['Mike', 'Joe'].map(e => getPermissions(e));
 >['Mike', 'Joe'].map(e => getPermissions(e)) : ("admin" | undefined)[]
 >                                            : ^^^^^^^^^^^^^^^^^^^^^^^
 >['Mike', 'Joe'].map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->                    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >['Mike', 'Joe'] : string[]
 >                : ^^^^^^^^
 >'Mike' : "Mike"
@@ -38,7 +38,7 @@ const admins = ['Mike', 'Joe'].map(e => getPermissions(e));
 >'Joe' : "Joe"
 >      : ^^^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >e => getPermissions(e) : (e: string) => "admin" | undefined
 >                       : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >e : string
@@ -71,11 +71,11 @@ const foundAdmins = admins.filter(isDefined);  // "admin"[]
 >admins.filter(isDefined) : "admin"[]
 >                         : ^^^^^^^^^
 >admins.filter : { <S extends "admin" | undefined>(predicate: (value: "admin" | undefined, index: number, array: ("admin" | undefined)[]) => value is S, thisArg?: any): S[]; (predicate: (value: "admin" | undefined, index: number, array: ("admin" | undefined)[]) => unknown, thisArg?: any): ("admin" | undefined)[]; }
->              : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>              : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >admins : ("admin" | undefined)[]
 >       : ^^^^^^^^^^^^^^^^^^^^^^^
 >filter : { <S extends "admin" | undefined>(predicate: (value: "admin" | undefined, index: number, array: ("admin" | undefined)[]) => value is S, thisArg?: any): S[]; (predicate: (value: "admin" | undefined, index: number, array: ("admin" | undefined)[]) => unknown, thisArg?: any): ("admin" | undefined)[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >isDefined : <T>(a: T | undefined) => a is T
 >          : ^ ^^ ^^             ^^^^^      
 
diff --git a/tests/baselines/reference/underscoreTest1.types b/tests/baselines/reference/underscoreTest1.types
index 8c6c941d7d78f..fd15bcdfd0b50 100644
--- a/tests/baselines/reference/underscoreTest1.types
+++ b/tests/baselines/reference/underscoreTest1.types
@@ -236,11 +236,11 @@ var flat = _.reduceRight(list, (a, b) => a.concat(b), []);
 >a.concat(b) : number[]
 >            : ^^^^^^^^
 >a.concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
->         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>         : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a : number[]
 >  : ^^^^^^^^
 >concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
->       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^
+>       : ^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >b : number[]
 >  : ^^^^^^^^
 >[] : undefined[]
@@ -672,7 +672,7 @@ _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floo
 >_([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floor(e)) : Dictionary<number[]>
 >                                                                                      : ^^^^^^^^^^^^^^^^^^^^
 >_([1.3, 2.1, 2.4]).groupBy : { (iterator?: Iterator_<number, any>, context?: any): Dictionary<number[]>; (propertyName: string): Dictionary<number[]>; }
->                           : ^^^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^           ^^^^^^   ^^^            ^^      ^^^           ^^^^^^   ^^^
+>                           : ^^^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >_([1.3, 2.1, 2.4]) : Underscore.WrappedArray<number>
 >                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >_ : Underscore.Static
@@ -686,7 +686,7 @@ _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floo
 >2.4 : 2.4
 >    : ^^^
 >groupBy : { (iterator?: Iterator_<number, any>, context?: any): Dictionary<number[]>; (propertyName: string): Dictionary<number[]>; }
->        : ^^^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^           ^^^^^^   ^^^            ^^      ^^^           ^^^^^^   ^^^
+>        : ^^^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^            ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(e: number, i?: number, list?: number[]) => Math.floor(e) : (e: number, i?: number, list?: number[]) => number
 >                                                          : ^ ^^      ^^ ^^^      ^^    ^^^        ^^^^^^^^^^^
 >e : number
@@ -2230,15 +2230,15 @@ _.chain([1, 2, 3, 200])
 >_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map(function (num) { return num * num }) : Underscore.ChainedArray<number>
 >                                                                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map : <U>(iterator: Iterator_<number, U>, context?: any) => Underscore.ChainedArray<U>
->                                                                                                        : ^ ^^        ^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
+>                                                                                                        : ^ ^^        ^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert) : Underscore.ChainedArray<number>
 >                                                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap : (interceptor: (object: number[]) => void) => Underscore.ChainedArray<number>
->                                                                                    : ^           ^^^      ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ 
+>                                                                                    : ^           ^^^      ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; }) : Underscore.ChainedArray<number>
 >                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >_.chain([1, 2, 3, 200])    .filter : (iterator: Iterator_<number, boolean>, context?: any) => Underscore.ChainedArray<number>
->                                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ 
+>                                   : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >_.chain([1, 2, 3, 200]) : Underscore.ChainedArray<number>
 >                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >_.chain : { <T>(list: T[]): Underscore.ChainedArray<T>; <T>(list: Dictionary<T>): Underscore.ChainedDictionary<T>; <T>(obj: T): Underscore.ChainedObject<T>; }
@@ -2260,7 +2260,7 @@ _.chain([1, 2, 3, 200])
 
     .filter(function (num) { return num % 2 == 0; })
 >filter : (iterator: Iterator_<number, boolean>, context?: any) => Underscore.ChainedArray<number>
->       : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ 
+>       : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >function (num) { return num % 2 == 0; } : (num: number) => boolean
 >                                        : ^   ^^^^^^^^^^^^^^^^^^^^
 >num : number
@@ -2278,7 +2278,7 @@ _.chain([1, 2, 3, 200])
 
     .tap(<any>alert)
 >tap : (interceptor: (object: number[]) => void) => Underscore.ChainedArray<number>
->    : ^           ^^^      ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^ 
+>    : ^           ^^^      ^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 ><any>alert : any
 >           : ^^^
 >alert : { (message?: any): void; (x: string): void; }
@@ -2286,7 +2286,7 @@ _.chain([1, 2, 3, 200])
 
     .map(function (num) { return num * num })
 >map : <U>(iterator: Iterator_<number, U>, context?: any) => Underscore.ChainedArray<U>
->    : ^ ^^        ^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
+>    : ^ ^^        ^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >function (num) { return num * num } : (num: number) => number
 >                                    : ^   ^^^^^^^^^^^^^^^^^^^
 >num : number
diff --git a/tests/baselines/reference/unionAndIntersectionInference1.types b/tests/baselines/reference/unionAndIntersectionInference1.types
index 5e4494d5e41ed..1c0e04a88fb97 100644
--- a/tests/baselines/reference/unionAndIntersectionInference1.types
+++ b/tests/baselines/reference/unionAndIntersectionInference1.types
@@ -284,7 +284,7 @@ const createTestAsync = (): Promise<ITest> => Promise.resolve().then(() => ({ na
 >Promise.resolve().then(() => ({ name: 'test' })) : Promise<ITest | { name: "test"; }>
 >                                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->                       : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>                       : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Promise.resolve() : Promise<void>
 >                  : ^^^^^^^^^^^^^
 >Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
@@ -294,7 +294,7 @@ const createTestAsync = (): Promise<ITest> => Promise.resolve().then(() => ({ na
 >resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >        : ^^^^^^             ^^^ ^^     ^^ ^^^                   ^^^ ^^     ^^                  ^^^                   ^^^
 >then : <TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>
->     : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^          ^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^        ^^^^^^^^   ^^^^^^^^ 
+>     : ^        ^^^^^^^^^        ^^^^^^^^^^           ^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => ({ name: 'test' }) : () => { name: "test"; }
 >                         : ^^^^^^^^^^^^^^^^^^^^^^^
 >({ name: 'test' }) : { name: "test"; }
diff --git a/tests/baselines/reference/unionCallMixedTypeParameterPresence.types b/tests/baselines/reference/unionCallMixedTypeParameterPresence.types
index 0baae15bdc24d..c16cd522b97af 100644
--- a/tests/baselines/reference/unionCallMixedTypeParameterPresence.types
+++ b/tests/baselines/reference/unionCallMixedTypeParameterPresence.types
@@ -31,11 +31,11 @@ const e2 = e.f((e) => e);
 >e.f((e) => e) : Err<2> | Err<0 | 1 | 2>
 >              : ^^^^^^^^^^^^^^^^^^^^^^^
 >e.f : (<U>(a: (err: 0) => U) => Err<U>) | (<U>(a: (err: 1) => U) => Err<U>) | ((a: (err: 2) => unknown) => Err<2>)
->    : ^^ ^^ ^^^   ^^^^^^^^^^^^^^    ^ ^^^^^^ ^^ ^^^   ^^^^^^^^^^^^^^    ^ ^^^^^^ ^^^   ^^^^^^^^       ^^^^^    ^ ^
+>    : ^^ ^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^   ^^^^^^^^       ^^^^^^^^^^^^
 >e : Err<0> | Err<1> | Ok<2>
 >  : ^^^^^^^^^^^^^^^^^^^^^^^
 >f : (<U>(a: (err: 0) => U) => Err<U>) | (<U>(a: (err: 1) => U) => Err<U>) | ((a: (err: 2) => unknown) => Err<2>)
->  : ^^ ^^ ^^^   ^^^^^^^^^^^^^^    ^ ^^^^^^ ^^ ^^^   ^^^^^^^^^^^^^^    ^ ^^^^^^ ^^^   ^^^^^^^^       ^^^^^    ^ ^
+>  : ^^ ^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^   ^^^^^^^^       ^^^^^^^^^^^^
 >(e) => e : (e: 0 | 1 | 2) => 0 | 1 | 2
 >         : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >e : 0 | 1 | 2
diff --git a/tests/baselines/reference/unionOfArraysFilterCall.types b/tests/baselines/reference/unionOfArraysFilterCall.types
index 0b5dd31e971fb..e9b00007fc2d1 100644
--- a/tests/baselines/reference/unionOfArraysFilterCall.types
+++ b/tests/baselines/reference/unionOfArraysFilterCall.types
@@ -25,7 +25,7 @@ interface Buzz {
 >([] as Fizz[] | Buzz[]).filter(item => item.id < 5) : (Fizz | Buzz)[]
 >                                                    : ^^^^^^^^^^^^^^^
 >([] as Fizz[] | Buzz[]).filter : { <S extends Fizz>(predicate: (value: Fizz, index: number, array: Fizz[]) => value is S, thisArg?: any): S[]; (predicate: (value: Fizz, index: number, array: Fizz[]) => unknown, thisArg?: any): Fizz[]; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, array: Buzz[]) => value is S, thisArg?: any): S[]; (predicate: (value: Buzz, index: number, array: Buzz[]) => unknown, thisArg?: any): Buzz[]; }
->                               : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^  ^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^  ^^^
+>                               : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >([] as Fizz[] | Buzz[]) : Fizz[] | Buzz[]
 >                        : ^^^^^^^^^^^^^^^
 >[] as Fizz[] | Buzz[] : Fizz[] | Buzz[]
@@ -33,7 +33,7 @@ interface Buzz {
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 >filter : { <S extends Fizz>(predicate: (value: Fizz, index: number, array: Fizz[]) => value is S, thisArg?: any): S[]; (predicate: (value: Fizz, index: number, array: Fizz[]) => unknown, thisArg?: any): Fizz[]; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, array: Buzz[]) => value is S, thisArg?: any): S[]; (predicate: (value: Buzz, index: number, array: Buzz[]) => unknown, thisArg?: any): Buzz[]; }
->       : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^  ^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >item => item.id < 5 : (item: Fizz | Buzz) => boolean
 >                    : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^
 >item : Fizz | Buzz
@@ -53,7 +53,7 @@ interface Buzz {
 >([] as Fizz[] | readonly Buzz[]).filter(item => item.id < 5) : (Fizz | Buzz)[]
 >                                                             : ^^^^^^^^^^^^^^^
 >([] as Fizz[] | readonly Buzz[]).filter : { <S extends Fizz>(predicate: (value: Fizz, index: number, array: Fizz[]) => value is S, thisArg?: any): S[]; (predicate: (value: Fizz, index: number, array: Fizz[]) => unknown, thisArg?: any): Fizz[]; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, array: readonly Buzz[]) => value is S, thisArg?: any): S[]; (predicate: (value: Buzz, index: number, array: readonly Buzz[]) => unknown, thisArg?: any): Buzz[]; }
->                                        : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^  ^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^  ^^^
+>                                        : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >([] as Fizz[] | readonly Buzz[]) : Fizz[] | readonly Buzz[]
 >                                 : ^^^^^^^^^^^^^^^^^^^^^^^^
 >[] as Fizz[] | readonly Buzz[] : Fizz[] | readonly Buzz[]
@@ -61,7 +61,7 @@ interface Buzz {
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 >filter : { <S extends Fizz>(predicate: (value: Fizz, index: number, array: Fizz[]) => value is S, thisArg?: any): S[]; (predicate: (value: Fizz, index: number, array: Fizz[]) => unknown, thisArg?: any): Fizz[]; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, array: readonly Buzz[]) => value is S, thisArg?: any): S[]; (predicate: (value: Buzz, index: number, array: readonly Buzz[]) => unknown, thisArg?: any): Buzz[]; }
->       : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^  ^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >item => item.id < 5 : (item: Fizz | Buzz) => boolean
 >                    : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^
 >item : Fizz | Buzz
@@ -80,16 +80,16 @@ interface Buzz {
 ([] as Fizz[] | Buzz[]).find(item => item);
 >([] as Fizz[] | Buzz[]).find(item => item) : Fizz | Buzz
 >                                           : ^^^^^^^^^^^
->([] as Fizz[] | Buzz[]).find : { <S extends Fizz>(predicate: (value: Fizz, index: number, obj: Fizz[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Fizz, index: number, obj: Fizz[]) => unknown, thisArg?: any): Fizz | undefined; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, obj: Buzz[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Buzz, index: number, obj: Buzz[]) => unknown, thisArg?: any): Buzz | undefined; }
->                             : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^            ^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^            ^^^
+>([] as Fizz[] | Buzz[]).find : { <S extends Fizz>(predicate: (value: Fizz, index: number, obj: Fizz[]) => value is S, thisArg?: any): S; (predicate: (value: Fizz, index: number, obj: Fizz[]) => unknown, thisArg?: any): Fizz; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, obj: Buzz[]) => value is S, thisArg?: any): S; (predicate: (value: Buzz, index: number, obj: Buzz[]) => unknown, thisArg?: any): Buzz; }
+>                             : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^
 >([] as Fizz[] | Buzz[]) : Fizz[] | Buzz[]
 >                        : ^^^^^^^^^^^^^^^
 >[] as Fizz[] | Buzz[] : Fizz[] | Buzz[]
 >                      : ^^^^^^^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
->find : { <S extends Fizz>(predicate: (value: Fizz, index: number, obj: Fizz[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Fizz, index: number, obj: Fizz[]) => unknown, thisArg?: any): Fizz | undefined; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, obj: Buzz[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Buzz, index: number, obj: Buzz[]) => unknown, thisArg?: any): Buzz | undefined; }
->     : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^            ^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^            ^^^
+>find : { <S extends Fizz>(predicate: (value: Fizz, index: number, obj: Fizz[]) => value is S, thisArg?: any): S; (predicate: (value: Fizz, index: number, obj: Fizz[]) => unknown, thisArg?: any): Fizz; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, obj: Buzz[]) => value is S, thisArg?: any): S; (predicate: (value: Buzz, index: number, obj: Buzz[]) => unknown, thisArg?: any): Buzz; }
+>     : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^
 >item => item : (item: Fizz | Buzz) => Fizz | Buzz
 >             : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >item : Fizz | Buzz
@@ -106,16 +106,16 @@ declare function isFizz(x: unknown): x is Fizz;
 ([] as Fizz[] | Buzz[]).find(isFizz);
 >([] as Fizz[] | Buzz[]).find(isFizz) : Fizz
 >                                     : ^^^^
->([] as Fizz[] | Buzz[]).find : { <S extends Fizz>(predicate: (value: Fizz, index: number, obj: Fizz[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Fizz, index: number, obj: Fizz[]) => unknown, thisArg?: any): Fizz | undefined; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, obj: Buzz[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Buzz, index: number, obj: Buzz[]) => unknown, thisArg?: any): Buzz | undefined; }
->                             : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^            ^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^            ^^^
+>([] as Fizz[] | Buzz[]).find : { <S extends Fizz>(predicate: (value: Fizz, index: number, obj: Fizz[]) => value is S, thisArg?: any): S; (predicate: (value: Fizz, index: number, obj: Fizz[]) => unknown, thisArg?: any): Fizz; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, obj: Buzz[]) => value is S, thisArg?: any): S; (predicate: (value: Buzz, index: number, obj: Buzz[]) => unknown, thisArg?: any): Buzz; }
+>                             : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^
 >([] as Fizz[] | Buzz[]) : Fizz[] | Buzz[]
 >                        : ^^^^^^^^^^^^^^^
 >[] as Fizz[] | Buzz[] : Fizz[] | Buzz[]
 >                      : ^^^^^^^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
->find : { <S extends Fizz>(predicate: (value: Fizz, index: number, obj: Fizz[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Fizz, index: number, obj: Fizz[]) => unknown, thisArg?: any): Fizz | undefined; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, obj: Buzz[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Buzz, index: number, obj: Buzz[]) => unknown, thisArg?: any): Buzz | undefined; }
->     : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^            ^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^            ^^^
+>find : { <S extends Fizz>(predicate: (value: Fizz, index: number, obj: Fizz[]) => value is S, thisArg?: any): S; (predicate: (value: Fizz, index: number, obj: Fizz[]) => unknown, thisArg?: any): Fizz; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, obj: Buzz[]) => value is S, thisArg?: any): S; (predicate: (value: Buzz, index: number, obj: Buzz[]) => unknown, thisArg?: any): Buzz; }
+>     : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^
 >isFizz : (x: unknown) => x is Fizz
 >       : ^ ^^       ^^^^^         
 
@@ -128,16 +128,16 @@ declare function isBuzz(x: unknown): x is Buzz;
 ([] as Fizz[] | Buzz[]).find(isBuzz);
 >([] as Fizz[] | Buzz[]).find(isBuzz) : Buzz
 >                                     : ^^^^
->([] as Fizz[] | Buzz[]).find : { <S extends Fizz>(predicate: (value: Fizz, index: number, obj: Fizz[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Fizz, index: number, obj: Fizz[]) => unknown, thisArg?: any): Fizz | undefined; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, obj: Buzz[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Buzz, index: number, obj: Buzz[]) => unknown, thisArg?: any): Buzz | undefined; }
->                             : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^            ^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^            ^^^
+>([] as Fizz[] | Buzz[]).find : { <S extends Fizz>(predicate: (value: Fizz, index: number, obj: Fizz[]) => value is S, thisArg?: any): S; (predicate: (value: Fizz, index: number, obj: Fizz[]) => unknown, thisArg?: any): Fizz; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, obj: Buzz[]) => value is S, thisArg?: any): S; (predicate: (value: Buzz, index: number, obj: Buzz[]) => unknown, thisArg?: any): Buzz; }
+>                             : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^
 >([] as Fizz[] | Buzz[]) : Fizz[] | Buzz[]
 >                        : ^^^^^^^^^^^^^^^
 >[] as Fizz[] | Buzz[] : Fizz[] | Buzz[]
 >                      : ^^^^^^^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
->find : { <S extends Fizz>(predicate: (value: Fizz, index: number, obj: Fizz[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Fizz, index: number, obj: Fizz[]) => unknown, thisArg?: any): Fizz | undefined; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, obj: Buzz[]) => value is S, thisArg?: any): S | undefined; (predicate: (value: Buzz, index: number, obj: Buzz[]) => unknown, thisArg?: any): Buzz | undefined; }
->     : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^            ^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^            ^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^            ^^^
+>find : { <S extends Fizz>(predicate: (value: Fizz, index: number, obj: Fizz[]) => value is S, thisArg?: any): S; (predicate: (value: Fizz, index: number, obj: Fizz[]) => unknown, thisArg?: any): Fizz; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, obj: Buzz[]) => value is S, thisArg?: any): S; (predicate: (value: Buzz, index: number, obj: Buzz[]) => unknown, thisArg?: any): Buzz; }
+>     : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^
 >isBuzz : (x: unknown) => x is Buzz
 >       : ^ ^^       ^^^^^         
 
@@ -194,7 +194,7 @@ declare function isBuzz(x: unknown): x is Buzz;
 >([] as [Fizz] | readonly [Buzz?]).filter(item => item?.id < 5) : (Fizz | Buzz)[]
 >                                                               : ^^^^^^^^^^^^^^^
 >([] as [Fizz] | readonly [Buzz?]).filter : { <S extends Fizz>(predicate: (value: Fizz, index: number, array: Fizz[]) => value is S, thisArg?: any): S[]; (predicate: (value: Fizz, index: number, array: Fizz[]) => unknown, thisArg?: any): Fizz[]; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, array: readonly Buzz[]) => value is S, thisArg?: any): S[]; (predicate: (value: Buzz, index: number, array: readonly Buzz[]) => unknown, thisArg?: any): Buzz[]; }
->                                         : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^  ^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^  ^^^
+>                                         : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >([] as [Fizz] | readonly [Buzz?]) : [Fizz] | readonly [Buzz?]
 >                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >[] as [Fizz] | readonly [Buzz?] : [Fizz] | readonly [Buzz?]
@@ -202,7 +202,7 @@ declare function isBuzz(x: unknown): x is Buzz;
 >[] : []
 >   : ^^
 >filter : { <S extends Fizz>(predicate: (value: Fizz, index: number, array: Fizz[]) => value is S, thisArg?: any): S[]; (predicate: (value: Fizz, index: number, array: Fizz[]) => unknown, thisArg?: any): Fizz[]; } | { <S extends Buzz>(predicate: (value: Buzz, index: number, array: readonly Buzz[]) => value is S, thisArg?: any): S[]; (predicate: (value: Buzz, index: number, array: readonly Buzz[]) => unknown, thisArg?: any): Buzz[]; }
->       : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^  ^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^
 >item => item?.id < 5 : (item: Fizz | Buzz) => boolean
 >                     : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^
 >item : Fizz | Buzz
diff --git a/tests/baselines/reference/unionOfClassCalls.types b/tests/baselines/reference/unionOfClassCalls.types
index 5007bc6dde5a7..92889ae878fbb 100644
--- a/tests/baselines/reference/unionOfClassCalls.types
+++ b/tests/baselines/reference/unionOfClassCalls.types
@@ -74,11 +74,11 @@ arr.map((a: number | string, index: number) => {
 >arr.map((a: number | string, index: number) => {     return index}) : number[]
 >                                                                    : ^^^^^^^^
 >arr.map : (<U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[])
->        : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^
+>        : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^
 >arr : number[] | string[]
 >    : ^^^^^^^^^^^^^^^^^^^
 >map : (<U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]) | (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[])
->    : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  ^
+>    : ^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^
 >(a: number | string, index: number) => {     return index} : (a: number | string, index: number) => number
 >                                                           : ^ ^^               ^^     ^^      ^^^^^^^^^^^
 >a : string | number
@@ -145,11 +145,11 @@ arr1.map((a: number, index: number) => {
 >arr1.map((a: number, index: number) => {     return index}) : number[]
 >                                                            : ^^^^^^^^
 >arr1.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->         : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>         : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >arr1 : number[]
 >     : ^^^^^^^^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(a: number, index: number) => {     return index} : (a: number, index: number) => number
 >                                                  : ^ ^^      ^^     ^^      ^^^^^^^^^^^
 >a : number
@@ -216,11 +216,11 @@ arr2.map((a:  string, index: number) => {
 >arr2.map((a:  string, index: number) => {     return index}) : number[]
 >                                                             : ^^^^^^^^
 >arr2.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->         : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>         : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >arr2 : string[]
 >     : ^^^^^^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >(a:  string, index: number) => {     return index} : (a: string, index: number) => number
 >                                                   : ^ ^^      ^^     ^^      ^^^^^^^^^^^
 >a : string
@@ -323,17 +323,17 @@ a.doThing().then((result: Bar | Baz) => {
 >a.doThing().then((result: Bar | Baz) => {	// whatever}) : Promise<void>
 >                                                        : ^^^^^^^^^^^^^
 >a.doThing().then : (<TResult1 = Baz, TResult2 = never>(onfulfilled?: ((value: Baz) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>) | (<TResult1 = Bar, TResult2 = never>(onfulfilled?: ((value: Bar) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>)
->                 : ^^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ ^^^^^^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ ^
+>                 : ^^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a.doThing() : Promise<Bar> | Promise<Baz>
 >            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a.doThing : (() => Promise<Bar>) | (() => Promise<Baz>)
->          : ^^^^^^^        ^^^ ^^^^^^^^^^^        ^^^ ^
+>          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a : Bar | Baz
 >  : ^^^^^^^^^
 >doThing : (() => Promise<Bar>) | (() => Promise<Baz>)
->        : ^^^^^^^        ^^^ ^^^^^^^^^^^        ^^^ ^
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >then : (<TResult1 = Baz, TResult2 = never>(onfulfilled?: ((value: Baz) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>) | (<TResult1 = Bar, TResult2 = never>(onfulfilled?: ((value: Bar) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>)
->     : ^^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ ^^^^^^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^               ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^   ^^^^^^^^ ^
+>     : ^^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^        ^^^^^^^^^^           ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(result: Bar | Baz) => {	// whatever} : (result: Bar | Baz) => void
 >                                      : ^      ^^         ^^^^^^^^^
 >result : Bar | Baz
diff --git a/tests/baselines/reference/unknownSymbolOffContextualType1.types b/tests/baselines/reference/unknownSymbolOffContextualType1.types
index ebc366cd53c76..9d472ca713d05 100644
--- a/tests/baselines/reference/unknownSymbolOffContextualType1.types
+++ b/tests/baselines/reference/unknownSymbolOffContextualType1.types
@@ -29,11 +29,11 @@ function getMaxWidth(elementNames: string[]) {
 >elementNames.map(function (name) {        return document.getElementById(name);    }) : HTMLElement[]
 >                                                                                      : ^^^^^^^^^^^^^
 >elementNames.map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->                 : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>                 : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >elementNames : string[]
 >             : ^^^^^^^^
 >map : <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >function (name) {        return document.getElementById(name);    } : (name: string) => HTMLElement
 >                                                                    : ^    ^^^^^^^^^^^^^^^^^^^^^^^^
 >name : string
@@ -58,11 +58,11 @@ function getMaxWidth(elementNames: string[]) {
 >elements.filter(function (e) {        return !e.isDisabled;    }) : HTMLElement[]
 >                                                                  : ^^^^^^^^^^^^^
 >elements.filter : { <S extends HTMLElement>(predicate: (value: HTMLElement, index: number, array: HTMLElement[]) => value is S, thisArg?: any): S[]; (predicate: (value: HTMLElement, index: number, array: HTMLElement[]) => unknown, thisArg?: any): HTMLElement[]; }
->                : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^  ^^^
+>                : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^
 >elements : HTMLElement[]
 >         : ^^^^^^^^^^^^^
 >filter : { <S extends HTMLElement>(predicate: (value: HTMLElement, index: number, array: HTMLElement[]) => value is S, thisArg?: any): S[]; (predicate: (value: HTMLElement, index: number, array: HTMLElement[]) => unknown, thisArg?: any): HTMLElement[]; }
->       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^  ^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^  ^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^
 >function (e) {        return !e.isDisabled;    } : (e: HTMLElement) => boolean
 >                                                 : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^
 >e : HTMLElement
@@ -85,11 +85,11 @@ function getMaxWidth(elementNames: string[]) {
 >enabled.map(function (e) {        return e.xyxyxyx;  // error expected here    }) : any[]
 >                                                                                  : ^^^^^
 >enabled.map : <U>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[]
->            : ^ ^^          ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>            : ^ ^^          ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >enabled : HTMLElement[]
 >        : ^^^^^^^^^^^^^
 >map : <U>(callbackfn: (value: HTMLElement, index: number, array: HTMLElement[]) => U, thisArg?: any) => U[]
->    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^  
+>    : ^ ^^          ^^^     ^^^^^^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >function (e) {        return e.xyxyxyx;  // error expected here    } : (e: HTMLElement) => any
 >                                                                     : ^ ^^^^^^^^^^^^^^^^^^^^^
 >e : HTMLElement
diff --git a/tests/baselines/reference/usePromiseFinally.types b/tests/baselines/reference/usePromiseFinally.types
index d592af2a378b9..44b9fcaaf2eaf 100644
--- a/tests/baselines/reference/usePromiseFinally.types
+++ b/tests/baselines/reference/usePromiseFinally.types
@@ -7,7 +7,7 @@ let promise1 = new Promise(function(resolve, reject) {})
 >new Promise(function(resolve, reject) {})                .finally(function() {}) : Promise<unknown>
 >                                                                                 : ^^^^^^^^^^^^^^^^
 >new Promise(function(resolve, reject) {})                .finally : (onfinally?: () => void) => Promise<unknown>
->                                                                  : ^         ^^^^^^^^^    ^^^^^        ^^^^^^^ 
+>                                                                  : ^         ^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^
 >new Promise(function(resolve, reject) {}) : Promise<unknown>
 >                                          : ^^^^^^^^^^^^^^^^
 >Promise : PromiseConstructor
@@ -21,7 +21,7 @@ let promise1 = new Promise(function(resolve, reject) {})
 
                 .finally(function() {});
 >finally : (onfinally?: () => void) => Promise<unknown>
->        : ^         ^^^^^^^^^    ^^^^^        ^^^^^^^ 
+>        : ^         ^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^
 >function() {} : () => void
 >              : ^^^^^^^^^^
 
diff --git a/tests/baselines/reference/variadicTuples2.types b/tests/baselines/reference/variadicTuples2.types
index 8a0ea1daf5118..34516c7d7582b 100644
--- a/tests/baselines/reference/variadicTuples2.types
+++ b/tests/baselines/reference/variadicTuples2.types
@@ -545,11 +545,11 @@ function pipe<T extends readonly unknown[]>(...args: [...T, (...values: T) => vo
 >args.slice(0, -1) : (((...values: T) => void) | T[number])[]
 >                  : ^^^^^^      ^^ ^^^^^    ^^^^^^^^^^^^^^^^
 >args.slice : (start?: number, end?: number) => (((...values: T) => void) | T[number])[]
->           : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^      ^^ ^^^^^    ^^^^^^^^^^^^^^  
+>           : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^      ^^ ^^^^^    ^^^^^^^^^^^^^^^^
 >args : [...T, (...values: T) => void]
 >     : ^^^^^^^^^^^      ^^ ^^^^^    ^
 >slice : (start?: number, end?: number) => (((...values: T) => void) | T[number])[]
->      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^      ^^ ^^^^^    ^^^^^^^^^^^^^^  
+>      : ^     ^^^      ^^   ^^^      ^^^^^^^^^^^      ^^ ^^^^^    ^^^^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 >-1 : -1
diff --git a/tests/cases/fourslash/codeFixAddMissingProperties22.ts b/tests/cases/fourslash/codeFixAddMissingProperties22.ts
index e2a06c9ac4920..5bd5ec0705b80 100644
--- a/tests/cases/fourslash/codeFixAddMissingProperties22.ts
+++ b/tests/cases/fourslash/codeFixAddMissingProperties22.ts
@@ -8,7 +8,7 @@ verify.codeFix({
     description: ts.Diagnostics.Add_missing_properties.message,
     newFileContent:
 `const x: Iterable<number> = {
-    [Symbol.iterator]: function(): Iterator<number> {
+    [Symbol.iterator]: function(): Iterator<number, any, undefined> {
         throw new Error("Function not implemented.");
     }
 }`,