Microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2025-11-18 17:21:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Clone node to remove location even when it has been modified if needed (#58706)

Browse Source
This commit is contained in:
Wesley Wigham
2024-05-31 15:16:16 -07:00
committed by GitHub
parent 6c058d4ef6
commit d4976c08b1
668 changed files with 4621 additions and 4428 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/checker.ts
+55 -15
View File
@@ -967,7 +967,7 @@ import {
ScriptKind,
ScriptTarget,
SetAccessorDeclaration,
setCommentRange,
setCommentRange as setCommentRangeWorker,
setEmitFlags,
setIdentifierTypeArguments,
setNodeFlags,
@@ -1094,7 +1094,7 @@ import {
VariableLikeDeclaration,
VariableStatement,
VarianceFlags,
visitEachChild,
visitEachChild as visitEachChildWorker,
visitNode,
visitNodes,
Visitor,
@@ -2426,7 +2426,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
function markAsSynthetic<T extends Node>(node: T): VisitResult<T> {
setTextRangePosEnd(node, -1, -1);
return visitEachChild(node, markAsSynthetic, /*context*/ undefined);
return visitEachChildWorker(node, markAsSynthetic, /*context*/ undefined);
}
function getEmitResolver(sourceFile: SourceFile, cancellationToken: CancellationToken, skipDiagnostics?: boolean) {
@@ -6032,21 +6032,21 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
* Unlike the utilities `setTextRange`, this checks if the `location` we're trying to set on `range` is within the
* same file as the active context. If not, the range is not applied. This prevents us from copying ranges across files,
* which will confuse the node printer (as it assumes all node ranges are within the current file).
* Additionally, if `range` _isn't synthetic_, and isn't in the current file, it will _copy_ it to _remove_ its' position
* Additionally, if `range` _isn't synthetic_, or isn't in the current file, it will _copy_ it to _remove_ its' position
* information.
*
* It also calls `setOriginalNode` to setup a `.original` pointer, since you basically *always* want these in the node builder.
*/
function setTextRange<T extends Node>(context: NodeBuilderContext, range: T, location: Node | undefined): T {
if (!nodeIsSynthesized(range) && !(range.flags & NodeFlags.Synthesized) && (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(range))) {
range = factory.cloneNode(range);
if (!nodeIsSynthesized(range) || !(range.flags & NodeFlags.Synthesized) || !context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(getOriginalNode(range))) {
range = factory.cloneNode(range); // if `range` is synthesized or originates in another file, copy it so it definitely has synthetic positions
}
if (range === location) return range;
if (!location) {
return range;
}
if (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(getOriginalNode(location))) {
return setOriginalNode(range, location);
return setOriginalNode(range, location); // if `location` is from another file, only set/update original pointer, and not positions, since copying text across files isn't supported by the emitter
}
return setTextRangeWorker(setOriginalNode(range, location), location);
}
@@ -6720,7 +6720,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
if (!nodeIsSynthesized(node) && getParseTreeNode(node) === node) {
return node;
}
return setTextRange(context, factory.cloneNode(visitEachChild(node, deepCloneOrReuseNode, /*context*/ undefined, deepCloneOrReuseNodes, deepCloneOrReuseNode)), node);
return setTextRange(context, factory.cloneNode(visitEachChildWorker(node, deepCloneOrReuseNode, /*context*/ undefined, deepCloneOrReuseNodes, deepCloneOrReuseNode)), node);
}
function deepCloneOrReuseNodes(
@@ -7067,6 +7067,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
const getterSignature = getSignatureFromDeclaration(getterDeclaration);
typeElements.push(
setCommentRange(
context,
signatureToSignatureDeclarationHelper(getterSignature, SyntaxKind.GetAccessor, context, { name: propertyName }) as GetAccessorDeclaration,
getterDeclaration,
),
@@ -7075,6 +7076,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
const setterSignature = getSignatureFromDeclaration(setterDeclaration);
typeElements.push(
setCommentRange(
context,
signatureToSignatureDeclarationHelper(setterSignature, SyntaxKind.SetAccessor, context, { name: propertyName }) as SetAccessorDeclaration,
setterDeclaration,
),
@@ -7132,12 +7134,20 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
else if (propertySymbol.valueDeclaration) {
// Copy comments to node for declaration emit
setCommentRange(node, propertySymbol.valueDeclaration);
setCommentRange(context, node, propertySymbol.valueDeclaration);
}
return node;
}
}
function setCommentRange<T extends Node>(context: NodeBuilderContext, node: T, range: Node): T {
if (context.enclosingFile && context.enclosingFile === getSourceFileOfNode(range)) {
// Copy comments to node for declaration emit
return setCommentRangeWorker(node, range);
}
return node;
}
function mapToTypeNodes(types: readonly Type[] | undefined, context: NodeBuilderContext, isBareList?: boolean): TypeNode[] | undefined {
if (some(types)) {
if (checkTruncationLength(context)) {
@@ -7579,7 +7589,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
if (context.tracker.canTrackSymbol && isComputedPropertyName(node) && isLateBindableName(node)) {
trackComputedName(node.expression, context.enclosingDeclaration, context);
}
let visited = visitEachChild(node, elideInitializerAndSetEmitFlags, /*context*/ undefined, /*nodesVisitor*/ undefined, elideInitializerAndSetEmitFlags);
let visited = visitEachChildWorker(node, elideInitializerAndSetEmitFlags, /*context*/ undefined, /*nodesVisitor*/ undefined, elideInitializerAndSetEmitFlags);
if (isBindingElement(visited)) {
visited = factory.updateBindingElement(
visited,
@@ -7992,6 +8002,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
if (!(result.kind & SyntaxKind.Identifier)) {
return factory.createIdentifier("(Missing type parameter)");
}
const decl = type.symbol?.declarations?.[0];
if (decl && isTypeParameterDeclaration(decl)) {
result = setTextRange(context, result, decl.name);
}
if (context.flags & NodeBuilderFlags.GenerateNamesForShadowedTypeParams) {
const rawtext = result.escapedText as string;
let i = context.typeParameterNamesByTextNextNameCount?.get(rawtext) || 0;
@@ -8393,7 +8407,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
name.symbol = sym!; // for quickinfo, which uses identifier symbol information
return setTextRange(context, setEmitFlags(name, EmitFlags.NoAsciiEscaping), node);
}
const updated = visitEachChild(node, c => attachSymbolToLeftmostIdentifier(c), /*context*/ undefined);
const updated = visitEachChildWorker(node, c => attachSymbolToLeftmostIdentifier(c), /*context*/ undefined);
if (updated !== node) {
setTextRange(context, updated, node);
}
@@ -8504,7 +8518,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
// is set to build for (even though we are reusing the node structure, the position information
// would make the printer print invalid spans for literals and identifiers, and the formatter would
// choke on the mismatched positonal spans between a parent and an injected child from another file).
return result === node ? setTextRange(context, factory.cloneNode(result), node) : result;
return result ? setTextRange(context, result, node) : undefined;
}
function createRecoveryBoundary() {
@@ -8769,7 +8783,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
|| (isPropertySignature(node) && !node.type && !node.initializer)
|| (isParameter(node) && !node.type && !node.initializer)
) {
let visited = visitEachChild(node, visitExistingNodeTreeSymbols, /*context*/ undefined);
let visited = visitEachChild(node, visitExistingNodeTreeSymbols);
if (visited === node) {
visited = setTextRange(context, factory.cloneNode(node), node);
}
@@ -8831,7 +8845,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
const visited = visitEachChild(node, visitExistingNodeTreeSymbols, /*context*/ undefined);
const visited = visitEachChild(node, visitExistingNodeTreeSymbols);
const clone = setTextRange(context, visited === node ? factory.cloneNode(node) : visited, node);
const flags = getEmitFlags(clone);
setEmitFlags(clone, flags | (context.flags & NodeBuilderFlags.MultilineObjectLiterals && isTypeLiteralNode(node) ? 0 : EmitFlags.SingleLine));
@@ -8878,7 +8892,33 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
}
return visitEachChild(node, visitExistingNodeTreeSymbols, /*context*/ undefined);
return visitEachChild(node, visitExistingNodeTreeSymbols);
function visitEachChild<T extends Node>(node: T, visitor: Visitor): T;
function visitEachChild<T extends Node>(node: T | undefined, visitor: Visitor): T | undefined;
function visitEachChild<T extends Node>(node: T | undefined, visitor: Visitor): T | undefined {
const nonlocalNode = !context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(node);
return visitEachChildWorker(node, visitor, /*context*/ undefined, nonlocalNode ? visitNodesWithoutCopyingPositions : undefined);
}
function visitNodesWithoutCopyingPositions(
nodes: NodeArray<Node> | undefined,
visitor: Visitor,
test?: (node: Node) => boolean,
start?: number,
count?: number,
): NodeArray<Node> | undefined {
let result = visitNodes(nodes, visitor, test, start, count);
if (result) {
if (result.pos !== -1 || result.end !== -1) {
if (result === nodes) {
result = factory.createNodeArray(nodes, nodes.hasTrailingComma);
}
setTextRangePosEnd(result, -1, -1);
}
}
return result;
}
function getEffectiveDotDotDotForParameter(p: ParameterDeclaration) {
return p.dotDotDotToken || (p.type && isJSDocVariadicType(p.type) ? factory.createToken(SyntaxKind.DotDotDotToken) : undefined);
tests/baselines/reference/2dArrays.types
+2 -2
View File
@@ -35,7 +35,7 @@ class Board {
>this.ships.every(function (val) { return val.isSunk; }) : boolean
> : ^^^^^^^
>this.ships.every : { <S extends Ship>(predicate: (value: Ship, index: number, array: Ship[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: Ship, index: number, array: Ship[]) => unknown, thisArg?: any): boolean; }
> : ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^
>this.ships : Ship[]
> : ^^^^^^
>this : this
@@ -43,7 +43,7 @@ class Board {
>ships : Ship[]
> : ^^^^^^
>every : { <S extends Ship>(predicate: (value: Ship, index: number, array: Ship[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: Ship, index: number, array: Ship[]) => unknown, thisArg?: any): boolean; }
> : ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^
>function (val) { return val.isSunk; } : (val: Ship) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^
>val : Ship
tests/baselines/reference/FunctionPropertyAssignments6_es6.types
+3 -3
View File
@@ -3,9 +3,9 @@
=== FunctionPropertyAssignments6_es6.ts ===
var v = { *<T>() { } }
>v : { ""<T>(): Generator<never, void, unknown>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>{ *<T>() { } } : { ""<T>(): Generator<never, void, unknown>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : <T>() => Generator<never, void, unknown>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/baselines/reference/MemberFunctionDeclaration7_es6.types
+1 -1
View File
@@ -7,5 +7,5 @@ class C {
*foo<T>() { }
>foo : <T>() => Generator<never, void, unknown>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
}
tests/baselines/reference/abstractClassUnionInstantiation.types
+8 -8
View File
@@ -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
tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash2.types
+1 -1
View File
@@ -25,7 +25,7 @@ type FnAlias<T> = typeof fn<T>;
>FnAlias : typeof fn<T>
> :
>fn : <T_1>() => T_1
> : ^ ^^^^^^^
> : ^^^^^^^^^^^
type Wat<T> = ClassAlias<T> & FnAlias<T>;
>Wat : Wat<T>
tests/baselines/reference/anyInferenceAnonymousFunctions.types
+10 -10
View File
@@ -8,11 +8,11 @@ var paired: any[];
paired.reduce(function (a1, a2) {
>paired.reduce(function (a1, a2) { return a1.concat({});} , []) : any
>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
>paired : any[]
> : ^^^^^
>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
>function (a1, a2) { return a1.concat({});} : (a1: any, a2: any) => any
> : ^ ^^^^^^^ ^^^^^^^^^^^^^
>a1 : any
@@ -35,11 +35,11 @@ paired.reduce(function (a1, a2) {
paired.reduce((b1, b2) => {
>paired.reduce((b1, b2) => { return b1.concat({});} , []) : any
>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
>paired : any[]
> : ^^^^^
>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
>(b1, b2) => { return b1.concat({});} : (b1: any, b2: any) => any
> : ^ ^^^^^^^ ^^^^^^^^^^^^^
>b1 : any
@@ -62,11 +62,11 @@ paired.reduce((b1, b2) => {
paired.reduce((b3, b4) => b3.concat({}), []);
>paired.reduce((b3, b4) => b3.concat({}), []) : any
>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
>paired : any[]
> : ^^^^^
>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
>(b3, b4) => b3.concat({}) : (b3: any, b4: any) => any
> : ^ ^^^^^^^ ^^^^^^^^^^^^^
>b3 : any
@@ -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
tests/baselines/reference/arrayConcatMap.types
+2 -2
View File
@@ -7,7 +7,7 @@ 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[]; }
@@ -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
tests/baselines/reference/arrayDestructuringInSwitch1.types
+2 -2
View File
@@ -47,11 +47,11 @@ export function evaluate(expression: Expression): boolean {
>operands.every((child) => evaluate(child)) : boolean
> : ^^^^^^^
>operands.every : { <S extends Expression>(predicate: (value: Expression, index: number, array: Expression[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: Expression, index: number, array: Expression[]) => unknown, thisArg?: any): boolean; } | { <S extends Expression>(predicate: (value: Expression, index: number, array: Expression[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: Expression, index: number, array: Expression[]) => unknown, thisArg?: any): boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^
>operands : Expression[] | [Expression]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>every : { <S extends Expression>(predicate: (value: Expression, index: number, array: Expression[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: Expression, index: number, array: Expression[]) => unknown, thisArg?: any): boolean; } | { <S extends Expression>(predicate: (value: Expression, index: number, array: Expression[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: Expression, index: number, array: Expression[]) => unknown, thisArg?: any): boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^
>(child) => evaluate(child) : (child: Expression) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^
>child : Expression
tests/baselines/reference/arrayEvery.types
+2 -2
View File
@@ -29,11 +29,11 @@ if (foo.every(isString)) {
>foo.every(isString) : boolean
> : ^^^^^^^
>foo.every : { <S extends string | number>(predicate: (value: string | number, index: number, array: (string | number)[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: string | number, index: number, array: (string | number)[]) => unknown, thisArg?: any): boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^
>foo : (string | number)[]
> : ^^^^^^^^^^^^^^^^^^^
>every : { <S extends string | number>(predicate: (value: string | number, index: number, array: (string | number)[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: string | number, index: number, array: (string | number)[]) => unknown, thisArg?: any): boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^ ^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^ ^^^
>isString : (x: unknown) => x is string
> : ^ ^^ ^^^^^
tests/baselines/reference/arrayFakeFlatNoCrashInferenceDeclarations.types
+3 -3
View File
File diff suppressed because one or more lines are too long
tests/baselines/reference/arrayFilter.types
+2 -2
View File
@@ -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; }
tests/baselines/reference/arrayFind.types
+4 -4
View File
@@ -41,11 +41,11 @@ 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 : (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; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
>isNumber : (x: any) => x is number
> : ^ ^^ ^^^^^
@@ -63,11 +63,11 @@ 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 : 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; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
>isNumber : (x: any) => x is number
> : ^ ^^ ^^^^^
tests/baselines/reference/arrayFlatMap.types
+4 -4
View File
@@ -17,11 +17,11 @@ 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 : number[]
> : ^^^^^^^^
>flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^ ^^ ^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^ ^^ ^^^^^^^^^^^^^
>(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
> : ^^^^^^
>[] : undefined[]
@@ -31,11 +31,11 @@ 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 : readonly number[]
> : ^^^^^^^^^^^^^^^^^
>flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | ReadonlyArray<U>, thisArg?: This) => U[]
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^ ^^ ^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^ ^^ ^^^^^^^^^^^^^
>(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
> : ^^^^^^
>[] : undefined[]
tests/baselines/reference/arrayFlatNoCrashInference.types
+2 -2
View File
@@ -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
> : ^^^^^^
}
tests/baselines/reference/arrayFlatNoCrashInferenceDeclarations.types
+2 -2
View File
@@ -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
> : ^^^^^^
}
tests/baselines/reference/arrowFunctionJSDocAnnotation.types
+1 -1
View File
@@ -25,7 +25,7 @@ const x = identity(
*/
param => param
>param => param : (param: number) => number | undefined
> : ^ ^^ ^^^^^ ^^^^^^^^^^^^
> : ^ ^^ ^^^^^ ^^^^^^^^^
>param : number
> : ^^^^^^
>param : number
tests/baselines/reference/assertionsAndNonReturningFunctions.types
+1 -1
View File
@@ -89,7 +89,7 @@ function fail() {
*/
function f1(x) {
>f1 : (x: any) => void
> : ^ ^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>x : any
> : ^^^
tests/baselines/reference/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.types
+61 -61
View File
@@ -386,7 +386,7 @@ module GenericSignaturesInvalid {
function foo<T>() {
>foo : <T>() => void
> : ^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^
var b: Base2;
>b : Base2
@@ -401,11 +401,11 @@ module GenericSignaturesInvalid {
>b.a = t.a : () => T
> : ^^^^^^^
>b.a : <T_1>() => T_1
> : ^ ^^^^^^^
> : ^^^^^^^^^^^
>b : Base2
> : ^^^^^
>a : <T_1>() => T_1
> : ^ ^^^^^^^
> : ^^^^^^^^^^^
>t.a : () => T
> : ^^^^^^^
>t : Target<T>
@@ -417,11 +417,11 @@ module GenericSignaturesInvalid {
>b.a = t.a2 : (x?: T) => T
> : ^ ^^^^^^^^^^
>b.a : <T_1>() => T_1
> : ^ ^^^^^^^
> : ^^^^^^^^^^^
>b : Base2
> : ^^^^^
>a : <T_1>() => T_1
> : ^ ^^^^^^^
> : ^^^^^^^^^^^
>t.a2 : (x?: T) => T
> : ^ ^^^^^^^^^^
>t : Target<T>
@@ -433,11 +433,11 @@ module GenericSignaturesInvalid {
>b.a = t.a3 : (x: T) => T
> : ^ ^^^^^^^^^
>b.a : <T_1>() => T_1
> : ^ ^^^^^^^
> : ^^^^^^^^^^^
>b : Base2
> : ^^^^^
>a : <T_1>() => T_1
> : ^ ^^^^^^^
> : ^^^^^^^^^^^
>t.a3 : (x: T) => T
> : ^ ^^^^^^^^^
>t : Target<T>
@@ -449,11 +449,11 @@ module GenericSignaturesInvalid {
>b.a = t.a4 : (x: T, y?: T) => T
> : ^ ^^^^^ ^^^^^^^^^^
>b.a : <T_1>() => T_1
> : ^ ^^^^^^^
> : ^^^^^^^^^^^
>b : Base2
> : ^^^^^
>a : <T_1>() => T_1
> : ^ ^^^^^^^
> : ^^^^^^^^^^^
>t.a4 : (x: T, y?: T) => T
> : ^ ^^^^^ ^^^^^^^^^^
>t : Target<T>
@@ -465,11 +465,11 @@ module GenericSignaturesInvalid {
>b.a = t.a5 : (x?: T, y?: T) => T
> : ^ ^^^^^^ ^^^^^^^^^^
>b.a : <T_1>() => T_1
> : ^ ^^^^^^^
> : ^^^^^^^^^^^
>b : Base2
> : ^^^^^
>a : <T_1>() => T_1
> : ^ ^^^^^^^
> : ^^^^^^^^^^^
>t.a5 : (x?: T, y?: T) => T
> : ^ ^^^^^^ ^^^^^^^^^^
>t : Target<T>
@@ -481,11 +481,11 @@ module GenericSignaturesInvalid {
>b.a2 = t.a : () => T
> : ^^^^^^^
>b.a2 : <T_1>(x?: T_1) => T_1
> : ^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a2 : <T_1>(x?: T_1) => T_1
> : ^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^^^^
>t.a : () => T
> : ^^^^^^^
>t : Target<T>
@@ -497,11 +497,11 @@ module GenericSignaturesInvalid {
>b.a2 = t.a2 : (x?: T) => T
> : ^ ^^^^^^^^^^
>b.a2 : <T_1>(x?: T_1) => T_1
> : ^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a2 : <T_1>(x?: T_1) => T_1
> : ^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^^^^
>t.a2 : (x?: T) => T
> : ^ ^^^^^^^^^^
>t : Target<T>
@@ -513,11 +513,11 @@ module GenericSignaturesInvalid {
>b.a2 = t.a3 : (x: T) => T
> : ^ ^^^^^^^^^
>b.a2 : <T_1>(x?: T_1) => T_1
> : ^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a2 : <T_1>(x?: T_1) => T_1
> : ^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^^^^
>t.a3 : (x: T) => T
> : ^ ^^^^^^^^^
>t : Target<T>
@@ -529,11 +529,11 @@ module GenericSignaturesInvalid {
>b.a2 = t.a4 : (x: T, y?: T) => T
> : ^ ^^^^^ ^^^^^^^^^^
>b.a2 : <T_1>(x?: T_1) => T_1
> : ^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a2 : <T_1>(x?: T_1) => T_1
> : ^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^^^^
>t.a4 : (x: T, y?: T) => T
> : ^ ^^^^^ ^^^^^^^^^^
>t : Target<T>
@@ -545,11 +545,11 @@ module GenericSignaturesInvalid {
>b.a2 = t.a5 : (x?: T, y?: T) => T
> : ^ ^^^^^^ ^^^^^^^^^^
>b.a2 : <T_1>(x?: T_1) => T_1
> : ^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a2 : <T_1>(x?: T_1) => T_1
> : ^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^^^^
>t.a5 : (x?: T, y?: T) => T
> : ^ ^^^^^^ ^^^^^^^^^^
>t : Target<T>
@@ -561,11 +561,11 @@ module GenericSignaturesInvalid {
>b.a3 = t.a : () => T
> : ^^^^^^^
>b.a3 : <T_1>(x: T_1) => T_1
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^ ^^ ^^^^^
>b : Base2
> : ^^^^^
>a3 : <T_1>(x: T_1) => T_1
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^ ^^ ^^^^^
>t.a : () => T
> : ^^^^^^^
>t : Target<T>
@@ -577,11 +577,11 @@ module GenericSignaturesInvalid {
>b.a3 = t.a2 : (x?: T) => T
> : ^ ^^^^^^^^^^
>b.a3 : <T_1>(x: T_1) => T_1
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^ ^^ ^^^^^
>b : Base2
> : ^^^^^
>a3 : <T_1>(x: T_1) => T_1
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^ ^^ ^^^^^
>t.a2 : (x?: T) => T
> : ^ ^^^^^^^^^^
>t : Target<T>
@@ -593,11 +593,11 @@ module GenericSignaturesInvalid {
>b.a3 = t.a3 : (x: T) => T
> : ^ ^^^^^^^^^
>b.a3 : <T_1>(x: T_1) => T_1
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^ ^^ ^^^^^
>b : Base2
> : ^^^^^
>a3 : <T_1>(x: T_1) => T_1
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^ ^^ ^^^^^
>t.a3 : (x: T) => T
> : ^ ^^^^^^^^^
>t : Target<T>
@@ -609,11 +609,11 @@ module GenericSignaturesInvalid {
>b.a3 = t.a4 : (x: T, y?: T) => T
> : ^ ^^^^^ ^^^^^^^^^^
>b.a3 : <T_1>(x: T_1) => T_1
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^ ^^ ^^^^^
>b : Base2
> : ^^^^^
>a3 : <T_1>(x: T_1) => T_1
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^ ^^ ^^^^^
>t.a4 : (x: T, y?: T) => T
> : ^ ^^^^^ ^^^^^^^^^^
>t : Target<T>
@@ -625,11 +625,11 @@ module GenericSignaturesInvalid {
>b.a3 = t.a5 : (x?: T, y?: T) => T
> : ^ ^^^^^^ ^^^^^^^^^^
>b.a3 : <T_1>(x: T_1) => T_1
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^ ^^ ^^^^^
>b : Base2
> : ^^^^^
>a3 : <T_1>(x: T_1) => T_1
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^ ^^ ^^^^^
>t.a5 : (x?: T, y?: T) => T
> : ^ ^^^^^^ ^^^^^^^^^^
>t : Target<T>
@@ -641,11 +641,11 @@ module GenericSignaturesInvalid {
>b.a4 = t.a : () => T
> : ^^^^^^^
>b.a4 : <T_1>(x: T_1, y?: T_1) => T_1
> : ^ ^^ ^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^ ^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a4 : <T_1>(x: T_1, y?: T_1) => T_1
> : ^ ^^ ^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^ ^^ ^^^ ^^^^^
>t.a : () => T
> : ^^^^^^^
>t : Target<T>
@@ -657,11 +657,11 @@ module GenericSignaturesInvalid {
>b.a4 = t.a2 : (x?: T) => T
> : ^ ^^^^^^^^^^
>b.a4 : <T_1>(x: T_1, y?: T_1) => T_1
> : ^ ^^ ^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^ ^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a4 : <T_1>(x: T_1, y?: T_1) => T_1
> : ^ ^^ ^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^ ^^ ^^^ ^^^^^
>t.a2 : (x?: T) => T
> : ^ ^^^^^^^^^^
>t : Target<T>
@@ -673,11 +673,11 @@ module GenericSignaturesInvalid {
>b.a4 = t.a3 : (x: T) => T
> : ^ ^^^^^^^^^
>b.a4 : <T_1>(x: T_1, y?: T_1) => T_1
> : ^ ^^ ^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^ ^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a4 : <T_1>(x: T_1, y?: T_1) => T_1
> : ^ ^^ ^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^ ^^ ^^^ ^^^^^
>t.a3 : (x: T) => T
> : ^ ^^^^^^^^^
>t : Target<T>
@@ -689,11 +689,11 @@ module GenericSignaturesInvalid {
>b.a4 = t.a4 : (x: T, y?: T) => T
> : ^ ^^^^^ ^^^^^^^^^^
>b.a4 : <T_1>(x: T_1, y?: T_1) => T_1
> : ^ ^^ ^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^ ^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a4 : <T_1>(x: T_1, y?: T_1) => T_1
> : ^ ^^ ^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^ ^^ ^^^ ^^^^^
>t.a4 : (x: T, y?: T) => T
> : ^ ^^^^^ ^^^^^^^^^^
>t : Target<T>
@@ -705,11 +705,11 @@ module GenericSignaturesInvalid {
>b.a4 = t.a5 : (x?: T, y?: T) => T
> : ^ ^^^^^^ ^^^^^^^^^^
>b.a4 : <T_1>(x: T_1, y?: T_1) => T_1
> : ^ ^^ ^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^ ^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a4 : <T_1>(x: T_1, y?: T_1) => T_1
> : ^ ^^ ^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^ ^^ ^^^ ^^^^^
>t.a5 : (x?: T, y?: T) => T
> : ^ ^^^^^^ ^^^^^^^^^^
>t : Target<T>
@@ -721,11 +721,11 @@ module GenericSignaturesInvalid {
>b.a5 = t.a : () => T
> : ^^^^^^^
>b.a5 : <T_1>(x?: T_1, y?: T_1) => T_1
> : ^ ^^ ^^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a5 : <T_1>(x?: T_1, y?: T_1) => T_1
> : ^ ^^ ^^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^ ^^^ ^^^^^
>t.a : () => T
> : ^^^^^^^
>t : Target<T>
@@ -737,11 +737,11 @@ module GenericSignaturesInvalid {
>b.a5 = t.a2 : (x?: T) => T
> : ^ ^^^^^^^^^^
>b.a5 : <T_1>(x?: T_1, y?: T_1) => T_1
> : ^ ^^ ^^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a5 : <T_1>(x?: T_1, y?: T_1) => T_1
> : ^ ^^ ^^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^ ^^^ ^^^^^
>t.a2 : (x?: T) => T
> : ^ ^^^^^^^^^^
>t : Target<T>
@@ -753,11 +753,11 @@ module GenericSignaturesInvalid {
>b.a5 = t.a3 : (x: T) => T
> : ^ ^^^^^^^^^
>b.a5 : <T_1>(x?: T_1, y?: T_1) => T_1
> : ^ ^^ ^^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a5 : <T_1>(x?: T_1, y?: T_1) => T_1
> : ^ ^^ ^^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^ ^^^ ^^^^^
>t.a3 : (x: T) => T
> : ^ ^^^^^^^^^
>t : Target<T>
@@ -769,11 +769,11 @@ module GenericSignaturesInvalid {
>b.a5 = t.a4 : (x: T, y?: T) => T
> : ^ ^^^^^ ^^^^^^^^^^
>b.a5 : <T_1>(x?: T_1, y?: T_1) => T_1
> : ^ ^^ ^^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a5 : <T_1>(x?: T_1, y?: T_1) => T_1
> : ^ ^^ ^^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^ ^^^ ^^^^^
>t.a4 : (x: T, y?: T) => T
> : ^ ^^^^^ ^^^^^^^^^^
>t : Target<T>
@@ -785,11 +785,11 @@ module GenericSignaturesInvalid {
>b.a5 = t.a5 : (x?: T, y?: T) => T
> : ^ ^^^^^^ ^^^^^^^^^^
>b.a5 : <T_1>(x?: T_1, y?: T_1) => T_1
> : ^ ^^ ^^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^ ^^^ ^^^^^
>b : Base2
> : ^^^^^
>a5 : <T_1>(x?: T_1, y?: T_1) => T_1
> : ^ ^^ ^^^ ^^ ^^^ ^^^^^
> : ^^^^^^ ^^^ ^^ ^^^ ^^^^^
>t.a5 : (x?: T, y?: T) => T
> : ^ ^^^^^^ ^^^^^^^^^^
>t : Target<T>
@@ -847,7 +847,7 @@ module GenericSignaturesValid {
this.a = <T>() => null; // ok, same T of required params
>this.a = <T>() => null : <T>() => any
> : ^^^^^^^^^^^^
> : ^ ^^^^^^^^^^
>this.a : <T>() => T
> : ^ ^^^^^^^
>this : this
@@ -855,7 +855,7 @@ module GenericSignaturesValid {
>a : <T>() => T
> : ^ ^^^^^^^
><T>() => null : <T>() => any
> : ^^^^^^^^^^^^
> : ^ ^^^^^^^^^^
this.a = <T>(x?: T) => null; // ok, same T of required params
>this.a = <T>(x?: T) => null : <T>(x?: T) => any
@@ -887,7 +887,7 @@ module GenericSignaturesValid {
this.a2 = <T>() => null; // ok, same T of required params
>this.a2 = <T>() => null : <T>() => any
> : ^^^^^^^^^^^^
> : ^ ^^^^^^^^^^
>this.a2 : <T>(x?: T) => T
> : ^ ^^ ^^^ ^^^^^
>this : this
@@ -895,7 +895,7 @@ module GenericSignaturesValid {
>a2 : <T>(x?: T) => T
> : ^ ^^ ^^^ ^^^^^
><T>() => null : <T>() => any
> : ^^^^^^^^^^^^
> : ^ ^^^^^^^^^^
this.a2 = <T>(x?: T) => null; // ok, same T of required params
>this.a2 = <T>(x?: T) => null : <T>(x?: T) => any
@@ -927,7 +927,7 @@ module GenericSignaturesValid {
this.a3 = <T>() => null; // ok, fewer required params
>this.a3 = <T>() => null : <T>() => any
> : ^^^^^^^^^^^^
> : ^ ^^^^^^^^^^
>this.a3 : <T>(x: T) => T
> : ^ ^^ ^^ ^^^^^
>this : this
@@ -935,7 +935,7 @@ module GenericSignaturesValid {
>a3 : <T>(x: T) => T
> : ^ ^^ ^^ ^^^^^
><T>() => null : <T>() => any
> : ^^^^^^^^^^^^
> : ^ ^^^^^^^^^^
this.a3 = <T>(x?: T) => null; // ok, fewer required params
>this.a3 = <T>(x?: T) => null : <T>(x?: T) => any
@@ -983,7 +983,7 @@ module GenericSignaturesValid {
this.a4 = <T>() => null; // ok, fewer required params
>this.a4 = <T>() => null : <T>() => any
> : ^^^^^^^^^^^^
> : ^ ^^^^^^^^^^
>this.a4 : <T>(x: T, y?: T) => T
> : ^ ^^ ^^ ^^ ^^^ ^^^^^
>this : this
@@ -991,7 +991,7 @@ module GenericSignaturesValid {
>a4 : <T>(x: T, y?: T) => T
> : ^ ^^ ^^ ^^ ^^^ ^^^^^
><T>() => null : <T>() => any
> : ^^^^^^^^^^^^
> : ^ ^^^^^^^^^^
this.a4 = <T>(x?: T, y?: T) => null; // ok, fewer required params
>this.a4 = <T>(x?: T, y?: T) => null : <T>(x?: T, y?: T) => any
@@ -1042,7 +1042,7 @@ module GenericSignaturesValid {
this.a5 = <T>() => null; // ok, fewer required params
>this.a5 = <T>() => null : <T>() => any
> : ^^^^^^^^^^^^
> : ^ ^^^^^^^^^^
>this.a5 : <T>(x?: T, y?: T) => T
> : ^ ^^ ^^^ ^^ ^^^ ^^^^^
>this : this
@@ -1050,7 +1050,7 @@ module GenericSignaturesValid {
>a5 : <T>(x?: T, y?: T) => T
> : ^ ^^ ^^^ ^^ ^^^ ^^^^^
><T>() => null : <T>() => any
> : ^^^^^^^^^^^^
> : ^ ^^^^^^^^^^
this.a5 = <T>(x?: T, y?: T) => null; // ok, fewer required params
>this.a5 = <T>(x?: T, y?: T) => null : <T>(x?: T, y?: T) => any
tests/baselines/reference/assignmentCompatWithNumericIndexer.types
+1 -1
View File
@@ -98,7 +98,7 @@ module Generics {
function foo<T extends Base>() {
>foo : <T extends Base>() => void
> : ^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^
var a: A<T>;
>a : A<T>
tests/baselines/reference/assignmentCompatWithNumericIndexer2.types
+1 -1
View File
@@ -87,7 +87,7 @@ module Generics {
function foo<T extends Base>() {
>foo : <T extends Base>() => void
> : ^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^
var a: A<T>;
>a : A<T>
tests/baselines/reference/assignmentCompatWithNumericIndexer3.types
+1 -1
View File
@@ -98,7 +98,7 @@ module Generics {
function foo<T extends Derived>() {
>foo : <T extends Derived>() => void
> : ^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^
var a: A<T>;
>a : A<T>
tests/baselines/reference/assignmentCompatWithStringIndexer.types
+1 -1
View File
@@ -157,7 +157,7 @@ module Generics {
function foo<T extends Base>() {
>foo : <T extends Base>() => void
> : ^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^
var b3: { [x: string]: Derived; };
>b3 : { [x: string]: Derived; }
tests/baselines/reference/assignmentCompatWithStringIndexer2.types
+1 -1
View File
@@ -141,7 +141,7 @@ module Generics {
function foo<T extends Base>() {
>foo : <T extends Base>() => void
> : ^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^
var b3: { [x: string]: Derived; };
>b3 : { [x: string]: Derived; }
tests/baselines/reference/assignmentCompatWithStringIndexer3.types
+1 -1
View File
@@ -56,7 +56,7 @@ module Generics {
function foo<T extends Derived>() {
>foo : <T extends Derived>() => void
> : ^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^
var a: A<T>;
>a : A<T>
tests/baselines/reference/assignmentCompatibilityForConstrainedTypeParameters.types
+2 -2
View File
@@ -3,13 +3,13 @@
=== assignmentCompatibilityForConstrainedTypeParameters.ts ===
function foo<T extends { bar: string }>() {
>foo : <T extends { bar: string; }>() => void
> : ^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^
>bar : string
> : ^^^^^^
function bar<S extends T>() {
>bar : <S extends T>() => void
> : ^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^^^^^^^^ ^^^^^^^^^^^
var x: S;
>x : S
tests/baselines/reference/assignmentToAnyArrayRestParameters.types
+1 -1
View File
@@ -59,7 +59,7 @@ function foo<T extends string[]>(
function bar<T extends string[], K extends number>() {
>bar : <T extends string[], K extends number>() => void
> : ^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^^^^^^^^ ^^ ^^^^^^^^^ ^^^^^^^^^^^
type T00 = string[]["0"];
>T00 : string
tests/baselines/reference/asyncArrowFunction_allowJs.types
+2 -2
View File
@@ -50,7 +50,7 @@ const d = async () => {
/** @type {function(function(): string): void} */
const f = (p) => {}
>f : (arg0: () => string) => void
> : ^^^^^^^^^^^^^ ^^^^^
> : ^^^^^^^ ^^^^^
>(p) => {} : (p: () => string) => void
> : ^ ^^^^^^^^ ^^^^^
>p : () => string
@@ -61,7 +61,7 @@ f(async () => {
>f(async () => { return 0}) : void
> : ^^^^
>f : (arg0: () => string) => void
> : ^^^^^^^^^^^^^ ^^^^^
> : ^^^^^^^ ^^^^^
>async () => { return 0} : () => Promise<number>
> : ^^^^^^^^^^^^^^^^^^^^^
tests/baselines/reference/asyncFunctionsAndStrictNullChecks.types
+5 -5
View File
@@ -5,7 +5,7 @@ declare namespace Windows.Foundation {
interface IPromise<TResult> {
then<U>(success?: (value: TResult) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>;
>then : { <U>(success?: (value: TResult) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U_1>(success?: (value: TResult) => IPromise<U_1>, error?: (error: any) => U_1, progress?: (progress: any) => void): IPromise<U_1>; <U_1>(success?: (value: TResult) => U_1, error?: (error: any) => IPromise<U_1>, progress?: (progress: any) => void): IPromise<U_1>; <U_1>(success?: (value: TResult) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): IPromise<U_1>; }
> : ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
>success : ((value: TResult) => IPromise<U>) | undefined
> : ^^ ^^ ^^^^^ ^^^^^^^^^^^^^
>value : TResult
@@ -19,7 +19,7 @@ declare namespace Windows.Foundation {
then<U>(success?: (value: TResult) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
>then : { <U_1>(success?: (value: TResult) => IPromise<U_1>, error?: (error: any) => IPromise<U_1>, progress?: (progress: any) => void): IPromise<U_1>; <U>(success?: (value: TResult) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U_1>(success?: (value: TResult) => U_1, error?: (error: any) => IPromise<U_1>, progress?: (progress: any) => void): IPromise<U_1>; <U_1>(success?: (value: TResult) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): IPromise<U_1>; }
> : ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
>success : ((value: TResult) => IPromise<U>) | undefined
> : ^^ ^^ ^^^^^ ^^^^^^^^^^^^^
>value : TResult
@@ -33,7 +33,7 @@ declare namespace Windows.Foundation {
then<U>(success?: (value: TResult) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>;
>then : { <U_1>(success?: (value: TResult) => IPromise<U_1>, error?: (error: any) => IPromise<U_1>, progress?: (progress: any) => void): IPromise<U_1>; <U_1>(success?: (value: TResult) => IPromise<U_1>, error?: (error: any) => U_1, progress?: (progress: any) => void): IPromise<U_1>; <U>(success?: (value: TResult) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U_1>(success?: (value: TResult) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): IPromise<U_1>; }
> : ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
>success : ((value: TResult) => U) | undefined
> : ^^ ^^ ^^^^^ ^^^^^^^^^^^^^
>value : TResult
@@ -47,7 +47,7 @@ declare namespace Windows.Foundation {
then<U>(success?: (value: TResult) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
>then : { <U_1>(success?: (value: TResult) => IPromise<U_1>, error?: (error: any) => IPromise<U_1>, progress?: (progress: any) => void): IPromise<U_1>; <U_1>(success?: (value: TResult) => IPromise<U_1>, error?: (error: any) => U_1, progress?: (progress: any) => void): IPromise<U_1>; <U_1>(success?: (value: TResult) => U_1, error?: (error: any) => IPromise<U_1>, progress?: (progress: any) => void): IPromise<U_1>; <U>(success?: (value: TResult) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
> : ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
>success : ((value: TResult) => U) | undefined
> : ^^ ^^ ^^^^^ ^^^^^^^^^^^^^
>value : TResult
@@ -61,7 +61,7 @@ declare namespace Windows.Foundation {
done<U>(success?: (value: TResult) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
>done : <U>(success?: (value: TResult) => any, error?: (error: any) => any, progress?: (progress: any) => void) => void
> : ^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^^^
> : ^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^^^
>success : ((value: TResult) => any) | undefined
> : ^^ ^^ ^^^^^ ^^^^^^^^^^^^^
>value : TResult
tests/baselines/reference/asyncYieldStarContextualType.types
+4 -4
View File
@@ -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">
> : ^ ^^ ^^ ^^^^^
tests/baselines/reference/awaitedType.types
+3 -3
View File
@@ -694,7 +694,7 @@ async function findManyWrapper<
>findMany(args) : CheckSelect<T, Promise<1>, Promise<2>>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>findMany : <T_1 extends { select?: string; include?: string; }>(args: T_1) => CheckSelect<T_1, Promise<1>, Promise<2>>
> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^^^^
>args : T
> : ^
@@ -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]
tests/baselines/reference/awaitedTypeJQuery.types
+6 -6
View File
@@ -12,7 +12,7 @@ interface PromiseBase<TR, TJ, TN,
SR, SJ, SN> {
then<ARD = never, AJD = never, AND = never,
>then : { <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF | ARP, AJD | AJF | AJP, AND | ANF | ANP, BRD | BRF | BRP, BJD | BJF | BJP, BND | BNF | BNP, CRD | CRF | CRP, CJD | CJF | CJP, CND | CNF | CNP, RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>; <ARF_1 = never, AJF_1 = never, ANF_1 = never, BRF_1 = never, BJF_1 = never, BNF_1 = never, CRF_1 = never, CJF_1 = never, CNF_1 = never, RRF_1 = never, RJF_1 = never, RNF_1 = never, ARP_1 = never, AJP_1 = never, ANP_1 = never, BRP_1 = never, BJP_1 = never, BNP_1 = never, CRP_1 = never, CJP_1 = never, CNP_1 = never, RRP_1 = never, RJP_1 = never, RNP_1 = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1> | Thenable<ARF_1> | ARF_1, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP_1, AJP_1, ANP_1, BRP_1, BJP_1, BNP_1, CRP_1, CJP_1, CNP_1, RRP_1, RJP_1, RNP_1> | Thenable<ANP_1> | ANP_1): PromiseBase<ARF_1 | ARP_1, AJF_1 | AJP_1, ANF_1 | ANP_1, BRF_1 | BRP_1, BJF_1 | BJP_1, BNF_1 | BNP_1, CRF_1 | CRP_1, CJF_1 | CJP_1, CNF_1 | CNP_1, RRF_1 | RRP_1, RJF_1 | RJP_1, RNF_1 | RNP_1>; <ARP_1 = never, AJP_1 = never, ANP_1 = never, BRP_1 = never, BJP_1 = never, BNP_1 = never, CRP_1 = never, CJP_1 = never, CNP_1 = never, RRP_1 = never, RJP_1 = never, RNP_1 = never>(doneFilter: null, failFilter: null, progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP_1, AJP_1, ANP_1, BRP_1, BJP_1, BNP_1, CRP_1, CJP_1, CNP_1, RRP_1, RJP_1, RNP_1> | Thenable<ANP_1> | ANP_1): PromiseBase<ARP_1, AJP_1, ANP_1, BRP_1, BJP_1, BNP_1, CRP_1, CJP_1, CNP_1, RRP_1, RJP_1, RNP_1>; <ARD_1 = never, AJD_1 = never, AND_1 = never, BRD_1 = never, BJD_1 = never, BND_1 = never, CRD_1 = never, CJD_1 = never, CND_1 = never, RRD_1 = never, RJD_1 = never, RND_1 = never, ARF_1 = never, AJF_1 = never, ANF_1 = never, BRF_1 = never, BJF_1 = never, BNF_1 = never, CRF_1 = never, CJF_1 = never, CNF_1 = never, RRF_1 = never, RJF_1 = never, RNF_1 = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD_1, AJD_1, AND_1, BRD_1, BJD_1, BND_1, CRD_1, CJD_1, CND_1, RRD_1, RJD_1, RND_1> | Thenable<ARD_1> | ARD_1, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1> | Thenable<ARF_1> | ARF_1, progressFilter?: null): PromiseBase<ARD_1 | ARF_1, AJD_1 | AJF_1, AND_1 | ANF_1, BRD_1 | BRF_1, BJD_1 | BJF_1, BND_1 | BNF_1, CRD_1 | CRF_1, CJD_1 | CJF_1, CND_1 | CNF_1, RRD_1 | RRF_1, RJD_1 | RJF_1, RND_1 | RNF_1>; <ARF_1 = never, AJF_1 = never, ANF_1 = never, BRF_1 = never, BJF_1 = never, BNF_1 = never, CRF_1 = never, CJF_1 = never, CNF_1 = never, RRF_1 = never, RJF_1 = never, RNF_1 = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1> | Thenable<ARF_1> | ARF_1, progressFilter?: null): PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1>; <ARD_1 = never, AJD_1 = never, AND_1 = never, BRD_1 = never, BJD_1 = never, BND_1 = never, CRD_1 = never, CJD_1 = never, CND_1 = never, RRD_1 = never, RJD_1 = never, RND_1 = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD_1, AJD_1, AND_1, BRD_1, BJD_1, BND_1, CRD_1, CJD_1, CND_1, RRD_1, RJD_1, RND_1> | Thenable<ARD_1> | ARD_1, failFilter?: null, progressFilter?: null): PromiseBase<ARD_1, AJD_1, AND_1, BRD_1, BJD_1, BND_1, CRD_1, CJD_1, CND_1, RRD_1, RJD_1, RND_1>; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
BRD = never, BJD = never, BND = never,
CRD = never, CJD = never, CND = never,
@@ -75,7 +75,7 @@ interface PromiseBase<TR, TJ, TN,
RRD | RRF | RRP, RJD | RJF | RJP, RND | RNF | RNP>;
then<ARF = never, AJF = never, ANF = never,
>then : { <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF_1 = never, AJF_1 = never, ANF_1 = never, BRF_1 = never, BJF_1 = never, BNF_1 = never, CRF_1 = never, CJF_1 = never, CNF_1 = never, RRF_1 = never, RJF_1 = never, RNF_1 = never, ARP_1 = never, AJP_1 = never, ANP_1 = never, BRP_1 = never, BJP_1 = never, BNP_1 = never, CRP_1 = never, CJP_1 = never, CNP_1 = never, RRP_1 = never, RJP_1 = never, RNP_1 = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1> | Thenable<ARF_1> | ARF_1, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP_1, AJP_1, ANP_1, BRP_1, BJP_1, BNP_1, CRP_1, CJP_1, CNP_1, RRP_1, RJP_1, RNP_1> | Thenable<ANP_1> | ANP_1): PromiseBase<ARD | ARF_1 | ARP_1, AJD | AJF_1 | AJP_1, AND | ANF_1 | ANP_1, BRD | BRF_1 | BRP_1, BJD | BJF_1 | BJP_1, BND | BNF_1 | BNP_1, CRD | CRF_1 | CRP_1, CJD | CJF_1 | CJP_1, CND | CNF_1 | CNP_1, RRD | RRF_1 | RRP_1, RJD | RJF_1 | RJP_1, RND | RNF_1 | RNP_1>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP, BRF | BRP, BJF | BJP, BNF | BNP, CRF | CRP, CJF | CJP, CNF | CNP, RRF | RRP, RJF | RJP, RNF | RNP>; <ARP_1 = never, AJP_1 = never, ANP_1 = never, BRP_1 = never, BJP_1 = never, BNP_1 = never, CRP_1 = never, CJP_1 = never, CNP_1 = never, RRP_1 = never, RJP_1 = never, RNP_1 = never>(doneFilter: null, failFilter: null, progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP_1, AJP_1, ANP_1, BRP_1, BJP_1, BNP_1, CRP_1, CJP_1, CNP_1, RRP_1, RJP_1, RNP_1> | Thenable<ANP_1> | ANP_1): PromiseBase<ARP_1, AJP_1, ANP_1, BRP_1, BJP_1, BNP_1, CRP_1, CJP_1, CNP_1, RRP_1, RJP_1, RNP_1>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF_1 = never, AJF_1 = never, ANF_1 = never, BRF_1 = never, BJF_1 = never, BNF_1 = never, CRF_1 = never, CJF_1 = never, CNF_1 = never, RRF_1 = never, RJF_1 = never, RNF_1 = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1> | Thenable<ARF_1> | ARF_1, progressFilter?: null): PromiseBase<ARD | ARF_1, AJD | AJF_1, AND | ANF_1, BRD | BRF_1, BJD | BJF_1, BND | BNF_1, CRD | CRF_1, CJD | CJF_1, CND | CNF_1, RRD | RRF_1, RJD | RJF_1, RND | RNF_1>; <ARF_1 = never, AJF_1 = never, ANF_1 = never, BRF_1 = never, BJF_1 = never, BNF_1 = never, CRF_1 = never, CJF_1 = never, CNF_1 = never, RRF_1 = never, RJF_1 = never, RNF_1 = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1> | Thenable<ARF_1> | ARF_1, progressFilter?: null): PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter?: null, progressFilter?: null): PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND>; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
BRF = never, BJF = never, BNF = never,
CRF = never, CJF = never, CNF = never,
@@ -123,7 +123,7 @@ interface PromiseBase<TR, TJ, TN,
RRF | RRP, RJF | RJP, RNF | RNP>;
then<ARP = never, AJP = never, ANP = never,
>then : { <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP_1 = never, AJP_1 = never, ANP_1 = never, BRP_1 = never, BJP_1 = never, BNP_1 = never, CRP_1 = never, CJP_1 = never, CNP_1 = never, RRP_1 = never, RJP_1 = never, RNP_1 = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP_1, AJP_1, ANP_1, BRP_1, BJP_1, BNP_1, CRP_1, CJP_1, CNP_1, RRP_1, RJP_1, RNP_1> | Thenable<ANP_1> | ANP_1): PromiseBase<ARD | ARF | ARP_1, AJD | AJF | AJP_1, AND | ANF | ANP_1, BRD | BRF | BRP_1, BJD | BJF | BJP_1, BND | BNF | BNP_1, CRD | CRF | CRP_1, CJD | CJF | CJP_1, CND | CNF | CNP_1, RRD | RRF | RRP_1, RJD | RJF | RJP_1, RND | RNF | RNP_1>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP_1 = never, AJP_1 = never, ANP_1 = never, BRP_1 = never, BJP_1 = never, BNP_1 = never, CRP_1 = never, CJP_1 = never, CNP_1 = never, RRP_1 = never, RJP_1 = never, RNP_1 = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP_1, AJP_1, ANP_1, BRP_1, BJP_1, BNP_1, CRP_1, CJP_1, CNP_1, RRP_1, RJP_1, RNP_1> | Thenable<ANP_1> | ANP_1): PromiseBase<ARF | ARP_1, AJF | AJP_1, ANF | ANP_1, BRF | BRP_1, BJF | BJP_1, BNF | BNP_1, CRF | CRP_1, CJF | CJP_1, CNF | CNP_1, RRF | RRP_1, RJF | RJP_1, RNF | RNP_1>; <ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: null, progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF, BRD | BRF, BJD | BJF, BND | BNF, CRD | CRF, CJD | CJF, CND | CNF, RRD | RRF, RJD | RJF, RND | RNF>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter?: null): PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter?: null, progressFilter?: null): PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND>; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
BRP = never, BJP = never, BNP = never,
CRP = never, CJP = never, CNP = never,
@@ -156,7 +156,7 @@ interface PromiseBase<TR, TJ, TN,
RRP, RJP, RNP>;
then<ARD = never, AJD = never, AND = never,
>then : { <ARD_1 = never, AJD_1 = never, AND_1 = never, BRD_1 = never, BJD_1 = never, BND_1 = never, CRD_1 = never, CJD_1 = never, CND_1 = never, RRD_1 = never, RJD_1 = never, RND_1 = never, ARF_1 = never, AJF_1 = never, ANF_1 = never, BRF_1 = never, BJF_1 = never, BNF_1 = never, CRF_1 = never, CJF_1 = never, CNF_1 = never, RRF_1 = never, RJF_1 = never, RNF_1 = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD_1, AJD_1, AND_1, BRD_1, BJD_1, BND_1, CRD_1, CJD_1, CND_1, RRD_1, RJD_1, RND_1> | Thenable<ARD_1> | ARD_1, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1> | Thenable<ARF_1> | ARF_1, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD_1 | ARF_1 | ARP, AJD_1 | AJF_1 | AJP, AND_1 | ANF_1 | ANP, BRD_1 | BRF_1 | BRP, BJD_1 | BJF_1 | BJP, BND_1 | BNF_1 | BNP, CRD_1 | CRF_1 | CRP, CJD_1 | CJF_1 | CJP, CND_1 | CNF_1 | CNP, RRD_1 | RRF_1 | RRP, RJD_1 | RJF_1 | RJP, RND_1 | RNF_1 | RNP>; <ARF_1 = never, AJF_1 = never, ANF_1 = never, BRF_1 = never, BJF_1 = never, BNF_1 = never, CRF_1 = never, CJF_1 = never, CNF_1 = never, RRF_1 = never, RJF_1 = never, RNF_1 = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1> | Thenable<ARF_1> | ARF_1, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF_1 | ARP, AJF_1 | AJP, ANF_1 | ANP, BRF_1 | BRP, BJF_1 | BJP, BNF_1 | BNP, CRF_1 | CRP, CJF_1 | CJP, CNF_1 | CNP, RRF_1 | RRP, RJF_1 | RJP, RNF_1 | RNP>; <ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: null, progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter?: null): PromiseBase<ARD | ARF, AJD | AJF, AND | ANF, BRD | BRF, BJD | BJF, BND | BNF, CRD | CRF, CJD | CJF, CND | CNF, RRD | RRF, RJD | RJF, RND | RNF>; <ARF_1 = never, AJF_1 = never, ANF_1 = never, BRF_1 = never, BJF_1 = never, BNF_1 = never, CRF_1 = never, CJF_1 = never, CNF_1 = never, RRF_1 = never, RJF_1 = never, RNF_1 = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1> | Thenable<ARF_1> | ARF_1, progressFilter?: null): PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1>; <ARD_1 = never, AJD_1 = never, AND_1 = never, BRD_1 = never, BJD_1 = never, BND_1 = never, CRD_1 = never, CJD_1 = never, CND_1 = never, RRD_1 = never, RJD_1 = never, RND_1 = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD_1, AJD_1, AND_1, BRD_1, BJD_1, BND_1, CRD_1, CJD_1, CND_1, RRD_1, RJD_1, RND_1> | Thenable<ARD_1> | ARD_1, failFilter?: null, progressFilter?: null): PromiseBase<ARD_1, AJD_1, AND_1, BRD_1, BJD_1, BND_1, CRD_1, CJD_1, CND_1, RRD_1, RJD_1, RND_1>; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
BRD = never, BJD = never, BND = never,
CRD = never, CJD = never, CND = never,
@@ -204,7 +204,7 @@ interface PromiseBase<TR, TJ, TN,
RRD | RRF, RJD | RJF, RND | RNF>;
then<ARF = never, AJF = never, ANF = never,
>then : { <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF_1 = never, AJF_1 = never, ANF_1 = never, BRF_1 = never, BJF_1 = never, BNF_1 = never, CRF_1 = never, CJF_1 = never, CNF_1 = never, RRF_1 = never, RJF_1 = never, RNF_1 = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1> | Thenable<ARF_1> | ARF_1, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD | ARF_1 | ARP, AJD | AJF_1 | AJP, AND | ANF_1 | ANP, BRD | BRF_1 | BRP, BJD | BJF_1 | BJP, BND | BNF_1 | BNP, CRD | CRF_1 | CRP, CJD | CJF_1 | CJP, CND | CNF_1 | CNP, RRD | RRF_1 | RRP, RJD | RJF_1 | RJP, RND | RNF_1 | RNP>; <ARF_1 = never, AJF_1 = never, ANF_1 = never, BRF_1 = never, BJF_1 = never, BNF_1 = never, CRF_1 = never, CJF_1 = never, CNF_1 = never, RRF_1 = never, RJF_1 = never, RNF_1 = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1> | Thenable<ARF_1> | ARF_1, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF_1 | ARP, AJF_1 | AJP, ANF_1 | ANP, BRF_1 | BRP, BJF_1 | BJP, BNF_1 | BNP, CRF_1 | CRP, CJF_1 | CJP, CNF_1 | CNP, RRF_1 | RRP, RJF_1 | RJP, RNF_1 | RNP>; <ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: null, progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never, ARF_1 = never, AJF_1 = never, ANF_1 = never, BRF_1 = never, BJF_1 = never, BNF_1 = never, CRF_1 = never, CJF_1 = never, CNF_1 = never, RRF_1 = never, RJF_1 = never, RNF_1 = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF_1, AJF_1, ANF_1, BRF_1, BJF_1, BNF_1, CRF_1, CJF_1, CNF_1, RRF_1, RJF_1, RNF_1> | Thenable<ARF_1> | ARF_1, progressFilter?: null): PromiseBase<ARD | ARF_1, AJD | AJF_1, AND | ANF_1, BRD | BRF_1, BJD | BJF_1, BND | BNF_1, CRD | CRF_1, CJD | CJF_1, CND | CNF_1, RRD | RRF_1, RJD | RJF_1, RND | RNF_1>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter?: null): PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter?: null, progressFilter?: null): PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND>; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
BRF = never, BJF = never, BNF = never,
CRF = never, CJF = never, CNF = never,
@@ -237,7 +237,7 @@ interface PromiseBase<TR, TJ, TN,
RRF, RJF, RNF>;
then<ARD = never, AJD = never, AND = never,
>then : { <ARD_1 = never, AJD_1 = never, AND_1 = never, BRD_1 = never, BJD_1 = never, BND_1 = never, CRD_1 = never, CJD_1 = never, CND_1 = never, RRD_1 = never, RJD_1 = never, RND_1 = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD_1, AJD_1, AND_1, BRD_1, BJD_1, BND_1, CRD_1, CJD_1, CND_1, RRD_1, RJD_1, RND_1> | Thenable<ARD_1> | ARD_1, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARD_1 | ARF | ARP, AJD_1 | AJF | AJP, AND_1 | ANF | ANP, BRD_1 | BRF | BRP, BJD_1 | BJF | BJP, BND_1 | BNF | BNP, CRD_1 | CRF | CRP, CJD_1 | CJF | CJP, CND_1 | CNF | CNP, RRD_1 | RRF | RRP, RJD_1 | RJF | RJP, RND_1 | RNF | RNP>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never, ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARF | ARP, AJF | AJP, ANF | ANP, BRF | BRP, BJF | BJP, BNF | BNP, CRF | CRP, CJF | CJP, CNF | CNP, RRF | RRP, RJF | RJP, RNF | RNP>; <ARP = never, AJP = never, ANP = never, BRP = never, BJP = never, BNP = never, CRP = never, CJP = never, CNP = never, RRP = never, RJP = never, RNP = never>(doneFilter: null, failFilter: null, progressFilter?: (t: TN, u: UN, v: VN, ...s: SN[]) => PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP> | Thenable<ANP> | ANP): PromiseBase<ARP, AJP, ANP, BRP, BJP, BNP, CRP, CJP, CNP, RRP, RJP, RNP>; <ARD_1 = never, AJD_1 = never, AND_1 = never, BRD_1 = never, BJD_1 = never, BND_1 = never, CRD_1 = never, CJD_1 = never, CND_1 = never, RRD_1 = never, RJD_1 = never, RND_1 = never, ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD_1, AJD_1, AND_1, BRD_1, BJD_1, BND_1, CRD_1, CJD_1, CND_1, RRD_1, RJD_1, RND_1> | Thenable<ARD_1> | ARD_1, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter?: null): PromiseBase<ARD_1 | ARF, AJD_1 | AJF, AND_1 | ANF, BRD_1 | BRF, BJD_1 | BJF, BND_1 | BNF, CRD_1 | CRF, CJD_1 | CJF, CND_1 | CNF, RRD_1 | RRF, RJD_1 | RJF, RND_1 | RNF>; <ARF = never, AJF = never, ANF = never, BRF = never, BJF = never, BNF = never, CRF = never, CJF = never, CNF = never, RRF = never, RJF = never, RNF = never>(doneFilter: null, failFilter: (t: TJ, u: UJ, v: VJ, ...s: SJ[]) => PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF> | Thenable<ARF> | ARF, progressFilter?: null): PromiseBase<ARF, AJF, ANF, BRF, BJF, BNF, CRF, CJF, CNF, RRF, RJF, RNF>; <ARD = never, AJD = never, AND = never, BRD = never, BJD = never, BND = never, CRD = never, CJD = never, CND = never, RRD = never, RJD = never, RND = never>(doneFilter: (t: TR, u: UR, v: VR, ...s: SR[]) => PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND> | Thenable<ARD> | ARD, failFilter?: null, progressFilter?: null): PromiseBase<ARD, AJD, AND, BRD, BJD, BND, CRD, CJD, CND, RRD, RJD, RND>; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
BRD = never, BJD = never, BND = never,
CRD = never, CJD = never, CND = never,
tests/baselines/reference/awaitedTypeNoLib.types
+2 -2
View File
@@ -52,11 +52,11 @@ class Thenable<T> {
>this.resolvePromise(result, resolve) : void
> : ^^^^
>this.resolvePromise : <TResult_1>(result: Thenable<TResult_1>, resolve: Receiver<TResult_1>) => void
> : ^ ^^ ^^ ^^ ^^ ^^^^^^^^^
> : ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^
>this : this
> : ^^^^
>resolvePromise : <TResult_1>(result: Thenable<TResult_1>, resolve: Receiver<TResult_1>) => void
> : ^ ^^ ^^ ^^ ^^ ^^^^^^^^^
> : ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^
>result : NotPromise<TResult> | Thenable<NotPromise<TResult>>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>resolve : Receiver<TResult>
tests/baselines/reference/awaitedTypeStrictNull.types
+4 -4
View File
@@ -219,15 +219,15 @@ class Api<D = {}> {
// Should result in `Promise<T>` instead of `Promise<Awaited<T>>`.
async post<T = D>() { return this.request<T>(); }
>post : <T = D>() => Promise<T>
> : ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^
>this.request<T>() : Promise<T>
> : ^^^^^^^^^^
>this.request : <D_1>() => Promise<D_1>
> : ^ ^^^^^^^
> : ^^^^^^^^^^^
>this : this
> : ^^^^
>request : <D_1>() => Promise<D_1>
> : ^ ^^^^^^^
> : ^^^^^^^^^^^
async request<D>(): Promise<D> { throw new Error(); }
>request : <D>() => Promise<D>
@@ -254,7 +254,7 @@ async function fn<T>(): Promise<T extends object ? { [K in keyof T]: Obj } : Obj
// Should not error.
return api.post();
>api.post() : Promise<T extends object ? { [K in keyof T]: Obj; } : Obj>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>api.post : <T_1 = {}>() => Promise<T_1>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>api : Api<{}>
tests/baselines/reference/baseExpressionTypeParameters.types
+2 -2
View File
@@ -5,7 +5,7 @@
function base<T>() {
>base : <T>() => typeof Base
> : ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^
class Base {
>Base : Base
@@ -26,7 +26,7 @@ class Gen<T> extends base<T>() {} // Error, T not in scope
>base<T>() : base<T>.Base
> : ^^^^^^^^^^^^
>base : <T>() => typeof Base
> : ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^
class Spec extends Gen<string> {}
>Spec : Spec
tests/baselines/reference/bestChoiceType.types
+6 -6
View File
@@ -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
tests/baselines/reference/betterErrorForUnionCall.types
+2 -2
View File
@@ -35,7 +35,7 @@ fnUnion("");
declare const fnUnion2: (<T extends number>(a: T) => void) | (<T>(a: string) => void)
>fnUnion2 : (<T extends number>(a: T) => void) | (<T>(a: string) => void)
> : ^^ ^^^^^^^^^ ^^ ^^ ^^^^^ ^^^^^^^^^ ^^ ^^^^^ ^
> : ^^ ^^^^^^^^^ ^^ ^^ ^^^^^ ^^^^^^ ^^ ^^ ^^^^^ ^
>a : T
> : ^
>a : string
@@ -45,7 +45,7 @@ fnUnion2("");
>fnUnion2("") : any
> : ^^^
>fnUnion2 : (<T extends number>(a: T) => void) | (<T>(a: string) => void)
> : ^^ ^^^^^^^^^ ^^ ^^ ^^^^^ ^^^^^^^^^ ^^ ^^^^^ ^
> : ^^ ^^^^^^^^^ ^^ ^^ ^^^^^ ^^^^^^ ^^ ^^ ^^^^^ ^
>"" : ""
> : ^^
tests/baselines/reference/bigintMissingES2019.types
+3 -3
View File
@@ -3,13 +3,13 @@
=== bigintMissingES2019.ts ===
declare function test<A, B extends A>(): void;
>test : <A, B extends A>() => void
> : ^ ^^^^^^^^^^^^ ^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^
test<{t?: string}, object>();
>test<{t?: string}, object>() : void
> : ^^^^
>test : <A, B extends A>() => void
> : ^ ^^^^^^^^^^^^ ^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^
>t : string
> : ^^^^^^
@@ -17,7 +17,7 @@ test<{t?: string}, bigint>();
>test<{t?: string}, bigint>() : void
> : ^^^^
>test : <A, B extends A>() => void
> : ^ ^^^^^^^^^^^^ ^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^
>t : string
> : ^^^^^^
tests/baselines/reference/bigintMissingES2020.types
+3 -3
View File
@@ -3,13 +3,13 @@
=== bigintMissingES2020.ts ===
declare function test<A, B extends A>(): void;
>test : <A, B extends A>() => void
> : ^ ^^^^^^^^^^^^ ^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^
test<{t?: string}, object>();
>test<{t?: string}, object>() : void
> : ^^^^
>test : <A, B extends A>() => void
> : ^ ^^^^^^^^^^^^ ^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^
>t : string
> : ^^^^^^
@@ -17,7 +17,7 @@ test<{t?: string}, bigint>();
>test<{t?: string}, bigint>() : void
> : ^^^^
>test : <A, B extends A>() => void
> : ^ ^^^^^^^^^^^^ ^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^
>t : string
> : ^^^^^^
tests/baselines/reference/bigintMissingESNext.types
+3 -3
View File
@@ -3,13 +3,13 @@
=== bigintMissingESNext.ts ===
declare function test<A, B extends A>(): void;
>test : <A, B extends A>() => void
> : ^ ^^^^^^^^^^^^ ^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^
test<{t?: string}, object>();
>test<{t?: string}, object>() : void
> : ^^^^
>test : <A, B extends A>() => void
> : ^ ^^^^^^^^^^^^ ^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^
>t : string
> : ^^^^^^
@@ -17,7 +17,7 @@ test<{t?: string}, bigint>();
>test<{t?: string}, bigint>() : void
> : ^^^^
>test : <A, B extends A>() => void
> : ^ ^^^^^^^^^^^^ ^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^
>t : string
> : ^^^^^^
tests/baselines/reference/bivariantInferences.types
+2 -2
View File
@@ -27,11 +27,11 @@ let x = a.equalsShallow(b);
>a.equalsShallow(b) : boolean
> : ^^^^^^^
>a.equalsShallow : (<T>(this: readonly T[], other: readonly T[]) => boolean) | (<T>(this: readonly T[], other: readonly T[]) => boolean) | (<T>(this: readonly T[], other: readonly T[]) => boolean) | (<T>(this: readonly T[], other: readonly T[]) => boolean)
> : ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^
> : ^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^
>a : (string | number)[] | null[] | undefined[] | {}[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>equalsShallow : (<T>(this: readonly T[], other: readonly T[]) => boolean) | (<T>(this: readonly T[], other: readonly T[]) => boolean) | (<T>(this: readonly T[], other: readonly T[]) => boolean) | (<T>(this: readonly T[], other: readonly T[]) => boolean)
> : ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^
> : ^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^
>b : (string | number)[] | null[] | undefined[] | {}[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/baselines/reference/bluebirdStaticThis.types
+61 -61
View File
@@ -27,7 +27,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static try<R>(dit: typeof Promise, fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>;
>try : { <R>(dit: typeof Promise, fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>; <R_1>(dit: typeof Promise, fn: () => R_1, args?: any[], ctx?: any): Promise<R_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -43,7 +43,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static try<R>(dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise<R>;
>try : { <R_1>(dit: typeof Promise, fn: () => Promise.Thenable<R_1>, args?: any[], ctx?: any): Promise<R_1>; <R>(dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise<R>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -57,7 +57,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static attempt<R>(dit: typeof Promise, fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>;
>attempt : { <R>(dit: typeof Promise, fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>; <R_1>(dit: typeof Promise, fn: () => R_1, args?: any[], ctx?: any): Promise<R_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -73,7 +73,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static attempt<R>(dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise<R>;
>attempt : { <R_1>(dit: typeof Promise, fn: () => Promise.Thenable<R_1>, args?: any[], ctx?: any): Promise<R_1>; <R>(dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise<R>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -105,7 +105,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static resolve<R>(dit: typeof Promise, value: Promise.Thenable<R>): Promise<R>;
>resolve : { (dit: typeof Promise): Promise<void>; <R>(dit: typeof Promise, value: Promise.Thenable<R>): Promise<R>; <R_1>(dit: typeof Promise, value: R_1): Promise<R_1>; }
> : ^^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -117,7 +117,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static resolve<R>(dit: typeof Promise, value: R): Promise<R>;
>resolve : { (dit: typeof Promise): Promise<void>; <R_1>(dit: typeof Promise, value: Promise.Thenable<R_1>): Promise<R_1>; <R>(dit: typeof Promise, value: R): Promise<R>; }
> : ^^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -157,7 +157,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static cast<R>(dit: typeof Promise, value: Promise.Thenable<R>): Promise<R>;
>cast : { <R>(dit: typeof Promise, value: Promise.Thenable<R>): Promise<R>; <R_1>(dit: typeof Promise, value: R_1): Promise<R_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -169,7 +169,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static cast<R>(dit: typeof Promise, value: R): Promise<R>;
>cast : { <R_1>(dit: typeof Promise, value: Promise.Thenable<R_1>): Promise<R_1>; <R>(dit: typeof Promise, value: R): Promise<R>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -207,7 +207,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static delay<R>(dit: typeof Promise, value: Promise.Thenable<R>, ms: number): Promise<R>;
>delay : { <R>(dit: typeof Promise, value: Promise.Thenable<R>, ms: number): Promise<R>; <R_1>(dit: typeof Promise, value: R_1, ms: number): Promise<R_1>; (dit: typeof Promise, ms: number): Promise<void>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -221,7 +221,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static delay<R>(dit: typeof Promise, value: R, ms: number): Promise<R>;
>delay : { <R_1>(dit: typeof Promise, value: Promise.Thenable<R_1>, ms: number): Promise<R_1>; <R>(dit: typeof Promise, value: R, ms: number): Promise<R>; (dit: typeof Promise, ms: number): Promise<void>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -265,7 +265,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static coroutine<R>(dit: typeof Promise, generatorFunction: Function): Function;
>coroutine : <R>(dit: typeof Promise, generatorFunction: Function) => Function
> : ^^^^ ^^ ^^ ^^ ^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -307,7 +307,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static all<R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<R[]>;
>all : { <R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<R[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[]): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[]): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -321,7 +321,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static all<R>(dit: typeof Promise, values: Promise.Thenable<R[]>): Promise<R[]>;
>all : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>): Promise<R_1[]>; <R>(dit: typeof Promise, values: Promise.Thenable<R[]>): Promise<R[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[]): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[]): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -333,7 +333,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static all<R>(dit: typeof Promise, values: Promise.Thenable<R>[]): Promise<R[]>;
>all : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>): Promise<R_1[]>; <R>(dit: typeof Promise, values: Promise.Thenable<R>[]): Promise<R[]>; <R_1>(dit: typeof Promise, values: R_1[]): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -345,7 +345,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static all<R>(dit: typeof Promise, values: R[]): Promise<R[]>;
>all : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[]): Promise<R_1[]>; <R>(dit: typeof Promise, values: R[]): Promise<R[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -375,7 +375,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static settle<R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<Promise.Inspection<R>[]>;
>settle : { <R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<Promise.Inspection<R>[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>): Promise<Promise.Inspection<R_1>[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[]): Promise<Promise.Inspection<R_1>[]>; <R_1>(dit: typeof Promise, values: R_1[]): Promise<Promise.Inspection<R_1>[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -391,7 +391,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static settle<R>(dit: typeof Promise, values: Promise.Thenable<R[]>): Promise<Promise.Inspection<R>[]>;
>settle : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>): Promise<Promise.Inspection<R_1>[]>; <R>(dit: typeof Promise, values: Promise.Thenable<R[]>): Promise<Promise.Inspection<R>[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[]): Promise<Promise.Inspection<R_1>[]>; <R_1>(dit: typeof Promise, values: R_1[]): Promise<Promise.Inspection<R_1>[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -405,7 +405,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static settle<R>(dit: typeof Promise, values: Promise.Thenable<R>[]): Promise<Promise.Inspection<R>[]>;
>settle : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>): Promise<Promise.Inspection<R_1>[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>): Promise<Promise.Inspection<R_1>[]>; <R>(dit: typeof Promise, values: Promise.Thenable<R>[]): Promise<Promise.Inspection<R>[]>; <R_1>(dit: typeof Promise, values: R_1[]): Promise<Promise.Inspection<R_1>[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -419,7 +419,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static settle<R>(dit: typeof Promise, values: R[]): Promise<Promise.Inspection<R>[]>;
>settle : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>): Promise<Promise.Inspection<R_1>[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>): Promise<Promise.Inspection<R_1>[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[]): Promise<Promise.Inspection<R_1>[]>; <R>(dit: typeof Promise, values: R[]): Promise<Promise.Inspection<R>[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -431,7 +431,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static any<R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<R>;
>any : { <R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<R>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>): Promise<R_1>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[]): Promise<R_1>; <R_1>(dit: typeof Promise, values: R_1[]): Promise<R_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -445,7 +445,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static any<R>(dit: typeof Promise, values: Promise.Thenable<R[]>): Promise<R>;
>any : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>): Promise<R_1>; <R>(dit: typeof Promise, values: Promise.Thenable<R[]>): Promise<R>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[]): Promise<R_1>; <R_1>(dit: typeof Promise, values: R_1[]): Promise<R_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -457,7 +457,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static any<R>(dit: typeof Promise, values: Promise.Thenable<R>[]): Promise<R>;
>any : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>): Promise<R_1>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>): Promise<R_1>; <R>(dit: typeof Promise, values: Promise.Thenable<R>[]): Promise<R>; <R_1>(dit: typeof Promise, values: R_1[]): Promise<R_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -469,7 +469,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static any<R>(dit: typeof Promise, values: R[]): Promise<R>;
>any : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>): Promise<R_1>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>): Promise<R_1>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[]): Promise<R_1>; <R>(dit: typeof Promise, values: R[]): Promise<R>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -479,7 +479,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static race<R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<R>;
>race : { <R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<R>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>): Promise<R_1>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[]): Promise<R_1>; <R_1>(dit: typeof Promise, values: R_1[]): Promise<R_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -493,7 +493,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static race<R>(dit: typeof Promise, values: Promise.Thenable<R[]>): Promise<R>;
>race : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>): Promise<R_1>; <R>(dit: typeof Promise, values: Promise.Thenable<R[]>): Promise<R>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[]): Promise<R_1>; <R_1>(dit: typeof Promise, values: R_1[]): Promise<R_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -505,7 +505,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static race<R>(dit: typeof Promise, values: Promise.Thenable<R>[]): Promise<R>;
>race : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>): Promise<R_1>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>): Promise<R_1>; <R>(dit: typeof Promise, values: Promise.Thenable<R>[]): Promise<R>; <R_1>(dit: typeof Promise, values: R_1[]): Promise<R_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -517,7 +517,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static race<R>(dit: typeof Promise, values: R[]): Promise<R>;
>race : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>): Promise<R_1>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>): Promise<R_1>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[]): Promise<R_1>; <R>(dit: typeof Promise, values: R[]): Promise<R>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -527,7 +527,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static some<R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, count: number): Promise<R[]>;
>some : { <R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, count: number): Promise<R[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, count: number): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], count: number): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], count: number): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -543,7 +543,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static some<R>(dit: typeof Promise, values: Promise.Thenable<R[]>, count: number): Promise<R[]>;
>some : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, count: number): Promise<R_1[]>; <R>(dit: typeof Promise, values: Promise.Thenable<R[]>, count: number): Promise<R[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], count: number): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], count: number): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -557,7 +557,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static some<R>(dit: typeof Promise, values: Promise.Thenable<R>[], count: number): Promise<R[]>;
>some : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, count: number): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, count: number): Promise<R_1[]>; <R>(dit: typeof Promise, values: Promise.Thenable<R>[], count: number): Promise<R[]>; <R_1>(dit: typeof Promise, values: R_1[], count: number): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -571,7 +571,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static some<R>(dit: typeof Promise, values: R[], count: number): Promise<R[]>;
>some : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, count: number): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, count: number): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], count: number): Promise<R_1[]>; <R>(dit: typeof Promise, values: R[], count: number): Promise<R[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -583,7 +583,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static join<R>(dit: typeof Promise, ...values: Promise.Thenable<R>[]): Promise<R[]>;
>join : { <R>(dit: typeof Promise, ...values: Promise.Thenable<R>[]): Promise<R[]>; <R_1>(dit: typeof Promise, ...values: R_1[]): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^^^^^^ ^^ ^^^^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -595,7 +595,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static join<R>(dit: typeof Promise, ...values: R[]): Promise<R[]>;
>join : { <R_1>(dit: typeof Promise, ...values: Promise.Thenable<R_1>[]): Promise<R_1[]>; <R>(dit: typeof Promise, ...values: R[]): Promise<R[]>; }
> : ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^^^^ ^^ ^^^ ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -605,7 +605,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static map<R, U>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable<U>): Promise<U[]>;
>map : { <R, U>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable<U>): Promise<U[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -629,7 +629,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static map<R, U>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
>map : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R, U>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -651,7 +651,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static map<R, U>(dit: typeof Promise, values: Promise.Thenable<R[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable<U>): Promise<U[]>;
>map : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R, U>(dit: typeof Promise, values: Promise.Thenable<R[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable<U>): Promise<U[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -673,7 +673,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static map<R, U>(dit: typeof Promise, values: Promise.Thenable<R[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
>map : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R, U>(dit: typeof Promise, values: Promise.Thenable<R[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -693,7 +693,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static map<R, U>(dit: typeof Promise, values: Promise.Thenable<R>[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable<U>): Promise<U[]>;
>map : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R, U>(dit: typeof Promise, values: Promise.Thenable<R>[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable<U>): Promise<U[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -715,7 +715,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static map<R, U>(dit: typeof Promise, values: Promise.Thenable<R>[], mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
>map : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R, U>(dit: typeof Promise, values: Promise.Thenable<R>[], mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -735,7 +735,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static map<R, U>(dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable<U>): Promise<U[]>;
>map : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R, U>(dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable<U>): Promise<U[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -755,7 +755,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static map<R, U>(dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>;
>map : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], mapper: (item: R_1, index: number, arrayLength: number) => U_1): Promise<U_1[]>; <R_1, U_1>(dit: typeof Promise, values: R_1[], mapper: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>): Promise<U_1[]>; <R, U>(dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise<U[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -773,7 +773,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static reduce<R, U>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable<U>, initialValue?: U): Promise<U>;
>reduce : { <R, U>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable<U>, initialValue?: U): Promise<U>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -801,7 +801,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static reduce<R, U>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
>reduce : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R, U>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -827,7 +827,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static reduce<R, U>(dit: typeof Promise, values: Promise.Thenable<R[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable<U>, initialValue?: U): Promise<U>;
>reduce : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R, U>(dit: typeof Promise, values: Promise.Thenable<R[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable<U>, initialValue?: U): Promise<U>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -853,7 +853,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static reduce<R, U>(dit: typeof Promise, values: Promise.Thenable<R[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
>reduce : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R, U>(dit: typeof Promise, values: Promise.Thenable<R[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -877,7 +877,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static reduce<R, U>(dit: typeof Promise, values: Promise.Thenable<R>[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable<U>, initialValue?: U): Promise<U>;
>reduce : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R, U>(dit: typeof Promise, values: Promise.Thenable<R>[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable<U>, initialValue?: U): Promise<U>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -903,7 +903,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static reduce<R, U>(dit: typeof Promise, values: Promise.Thenable<R>[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
>reduce : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R, U>(dit: typeof Promise, values: Promise.Thenable<R>[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -927,7 +927,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static reduce<R, U>(dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable<U>, initialValue?: U): Promise<U>;
>reduce : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R, U>(dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable<U>, initialValue?: U): Promise<U>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -951,7 +951,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static reduce<R, U>(dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>;
>reduce : { <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => U_1, initialValue?: U_1): Promise<U_1>; <R_1, U_1>(dit: typeof Promise, values: R_1[], reducer: (total: U_1, current: R_1, index: number, arrayLength: number) => Promise.Thenable<U_1>, initialValue?: U_1): Promise<U_1>; <R, U>(dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise<U>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -973,7 +973,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static filter<R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R[]>;
>filter : { <R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -997,7 +997,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static filter<R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
>filter : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -1019,7 +1019,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static filter<R>(dit: typeof Promise, values: Promise.Thenable<R[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R[]>;
>filter : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R>(dit: typeof Promise, values: Promise.Thenable<R[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -1041,7 +1041,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static filter<R>(dit: typeof Promise, values: Promise.Thenable<R[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
>filter : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R>(dit: typeof Promise, values: Promise.Thenable<R[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -1061,7 +1061,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static filter<R>(dit: typeof Promise, values: Promise.Thenable<R>[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R[]>;
>filter : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R>(dit: typeof Promise, values: Promise.Thenable<R>[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -1083,7 +1083,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static filter<R>(dit: typeof Promise, values: Promise.Thenable<R>[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
>filter : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R>(dit: typeof Promise, values: Promise.Thenable<R>[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -1103,7 +1103,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static filter<R>(dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R[]>;
>filter : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R>(dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -1123,7 +1123,7 @@ export declare class Promise<R> implements Promise.Thenable<R> {
static filter<R>(dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
>filter : { <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R_1>[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1[]>, filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: Promise.Thenable<R_1>[], filterer: (item: R_1, index: number, arrayLength: number) => boolean): Promise<R_1[]>; <R_1>(dit: typeof Promise, values: R_1[], filterer: (item: R_1, index: number, arrayLength: number) => Promise.Thenable<boolean>): Promise<R_1[]>; <R>(dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>dit : typeof Promise
> : ^^^^^^^^^^^^^^
>Promise : typeof Promise
@@ -1144,7 +1144,7 @@ export declare module Promise {
export interface Thenable<R> {
then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected: (error: any) => Thenable<U>): Thenable<U>;
>then : { <U>(onFulfilled: (value: R) => Thenable<U>, onRejected: (error: any) => Thenable<U>): Thenable<U>; <U_1>(onFulfilled: (value: R) => Thenable<U_1>, onRejected?: (error: any) => U_1): Thenable<U_1>; <U_1>(onFulfilled: (value: R) => U_1, onRejected: (error: any) => Thenable<U_1>): Thenable<U_1>; <U_1>(onFulfilled?: (value: R) => U_1, onRejected?: (error: any) => U_1): Thenable<U_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^
>onFulfilled : (value: R) => Thenable<U>
> : ^ ^^ ^^^^^
>value : R
@@ -1156,7 +1156,7 @@ export declare module Promise {
then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected?: (error: any) => U): Thenable<U>;
>then : { <U_1>(onFulfilled: (value: R) => Thenable<U_1>, onRejected: (error: any) => Thenable<U_1>): Thenable<U_1>; <U>(onFulfilled: (value: R) => Thenable<U>, onRejected?: (error: any) => U): Thenable<U>; <U_1>(onFulfilled: (value: R) => U_1, onRejected: (error: any) => Thenable<U_1>): Thenable<U_1>; <U_1>(onFulfilled?: (value: R) => U_1, onRejected?: (error: any) => U_1): Thenable<U_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^
>onFulfilled : (value: R) => Thenable<U>
> : ^ ^^ ^^^^^
>value : R
@@ -1168,7 +1168,7 @@ export declare module Promise {
then<U>(onFulfilled: (value: R) => U, onRejected: (error: any) => Thenable<U>): Thenable<U>;
>then : { <U_1>(onFulfilled: (value: R) => Thenable<U_1>, onRejected: (error: any) => Thenable<U_1>): Thenable<U_1>; <U_1>(onFulfilled: (value: R) => Thenable<U_1>, onRejected?: (error: any) => U_1): Thenable<U_1>; <U>(onFulfilled: (value: R) => U, onRejected: (error: any) => Thenable<U>): Thenable<U>; <U_1>(onFulfilled?: (value: R) => U_1, onRejected?: (error: any) => U_1): Thenable<U_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^
>onFulfilled : (value: R) => U
> : ^ ^^ ^^^^^
>value : R
@@ -1180,7 +1180,7 @@ export declare module Promise {
then<U>(onFulfilled?: (value: R) => U, onRejected?: (error: any) => U): Thenable<U>;
>then : { <U_1>(onFulfilled: (value: R) => Thenable<U_1>, onRejected: (error: any) => Thenable<U_1>): Thenable<U_1>; <U_1>(onFulfilled: (value: R) => Thenable<U_1>, onRejected?: (error: any) => U_1): Thenable<U_1>; <U_1>(onFulfilled: (value: R) => U_1, onRejected: (error: any) => Thenable<U_1>): Thenable<U_1>; <U>(onFulfilled?: (value: R) => U, onRejected?: (error: any) => U): Thenable<U>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^
>onFulfilled : (value: R) => U
> : ^ ^^ ^^^^^
>value : R
tests/baselines/reference/booleanFilterAnyArray.types
+8 -8
View File
@@ -46,11 +46,11 @@ 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 : 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>; }
> : ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^^ ^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^ ^^^ ^^^^^^^^^^ ^^^ ^^^ ^^^
>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
tests/baselines/reference/callChain.types
+2 -2
View File
@@ -456,7 +456,7 @@ const v: number | undefined = o4?.(incr);
// GH#33744
declare const o5: <T>() => undefined | (() => void);
>o5 : <T>() => undefined | (() => void)
> : ^^^^^^^^^
> : ^ ^^^^^^^
o5<number>()?.();
>o5<number>()?.() : void | undefined
@@ -464,7 +464,7 @@ o5<number>()?.();
>o5<number>() : (() => void) | undefined
> : ^^^^^^^ ^^^^^^^^^^^^^
>o5 : <T>() => undefined | (() => void)
> : ^^^^^^^^^
> : ^ ^^^^^^^
// GH#36031
o2?.b()!.toString;
tests/baselines/reference/callWithWrongNumberOfTypeArguments.types
+4 -4
View File
@@ -3,23 +3,23 @@
=== callWithWrongNumberOfTypeArguments.ts ===
function f<T, U>() { }
>f : <T, U>() => void
> : ^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
f<number>();
>f<number>() : void
> : ^^^^
>f : <T, U>() => void
> : ^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
f<number, string>();
>f<number, string>() : void
> : ^^^^
>f : <T, U>() => void
> : ^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
f<number, string, number>();
>f<number, string, number>() : void
> : ^^^^
>f : <T, U>() => void
> : ^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
tests/baselines/reference/callbacksDontShareTypes.types
+2 -2
View File
@@ -21,7 +21,7 @@ interface Collection<T> {
interface Combinators {
map<T, U>(c: Collection<T>, f: (x: T) => U): Collection<U>;
>map : { <T, U>(c: Collection<T>, f: (x: T) => U): Collection<U>; <T_1>(c: Collection<T_1>, f: (x: T_1) => any): Collection<any>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>c : Collection<T>
> : ^^^^^^^^^^^^^
>f : (x: T) => U
@@ -31,7 +31,7 @@ interface Combinators {
map<T>(c: Collection<T>, f: (x: T) => any): Collection<any>;
>map : { <T_1, U>(c: Collection<T_1>, f: (x: T_1) => U): Collection<U>; <T>(c: Collection<T>, f: (x: T) => any): Collection<any>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>c : Collection<T>
> : ^^^^^^^^^^^^^
>f : (x: T) => any
tests/baselines/reference/castExpressionParentheses.types
+2 -2
View File
@@ -258,9 +258,9 @@ new (<any>A());
>(<Tany>()=> {})() : void
> : ^^^^
>(<Tany>()=> {}) : <Tany>() => void
> : ^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^
><Tany>()=> {} : <Tany>() => void
> : ^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^
(<any>function foo() { })();
>(<any>function foo() { })() : any
tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.types
+8 -8
View File
@@ -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
tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.types
+22 -22
View File
@@ -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
tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.types
+2 -2
View File
@@ -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
tests/baselines/reference/checkInfiniteExpansionTermination2.types
+1 -1
View File
@@ -23,7 +23,7 @@ declare function combineLatest(): void;
function fn<T>() {
>fn : <T>() => void
> : ^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^
var values: ISubject<any>[] = [];
>values : ISubject<any>[]
tests/baselines/reference/checkJsdocParamOnVariableDeclaredFunctionExpression.types
+3 -3
View File
@@ -8,11 +8,11 @@
*/
var x = function foo(n, s) {}
>x : (n?: number | undefined, s?: string) => void
> : ^ ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^ ^^^ ^^^^^^^^^
>function foo(n, s) {} : (n?: number | undefined, s?: string) => void
> : ^ ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^ ^^^ ^^^^^^^^^
>foo : (n?: number | undefined, s?: string) => void
> : ^ ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^ ^^^ ^^^^^^^^^
>n : number
> : ^^^^^^
>s : string
tests/baselines/reference/checkJsdocParamTag1.types
+4 -4
View File
@@ -8,7 +8,7 @@
*/
function foo(n, s) {}
>foo : (n?: number | undefined, s?: string) => void
> : ^ ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^ ^^^ ^^^^^^^^^
>n : number
> : ^^^^^^
>s : string
@@ -18,13 +18,13 @@ foo();
>foo() : void
> : ^^^^
>foo : (n?: number | undefined, s?: string) => void
> : ^ ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^ ^^^ ^^^^^^^^^
foo(1);
>foo(1) : void
> : ^^^^
>foo : (n?: number | undefined, s?: string) => void
> : ^ ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^ ^^^ ^^^^^^^^^
>1 : 1
> : ^
@@ -32,7 +32,7 @@ foo(1, "hi");
>foo(1, "hi") : void
> : ^^^^
>foo : (n?: number | undefined, s?: string) => void
> : ^ ^^^ ^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^ ^^^ ^^^^^^^^^
>1 : 1
> : ^
>"hi" : "hi"
tests/baselines/reference/checkJsdocReturnTag1.types
+1 -1
View File
@@ -19,7 +19,7 @@ function f() {
*/
function f1() {
>f1 : () => string | undefined
> : ^^^^^^ ^^^^^^^^^^^^
> : ^^^^^^ ^^^^^^^^^
return "hello world";
>"hello world" : "hello world"
tests/baselines/reference/checkJsdocTypeTagOnObjectProperty1.types
+8 -8
View File
@@ -10,9 +10,9 @@ var lol = "hello Lol"
const obj = {
>obj : { [x: string]: string | number | ((arg0: number) => number) | undefined; foo: string | undefined; bar: string | undefined; method1(arg0: number): number; lol: string; arrowFunc: (arg0: number) => number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^ ^^ ^^^
>{ /** @type {string|undefined} */ foo: undefined, /** @type {string|undefined} */ bar: "42", /** @type {function(number): number} */ method1(n1) { return n1 + 42; }, /** @type {string} */ lol, /** @type {number} */ ['b' + 'ar1']: 42, /** @type {function(number): number} */ arrowFunc: (num) => num + 42} : { [x: string]: string | number | ((arg0: number) => number) | undefined; foo: string | undefined; bar: string | undefined; method1(arg0: number): number; lol: string; arrowFunc: (arg0: number) => number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^ ^^ ^^^
/** @type {string|undefined} */
foo: undefined,
@@ -83,7 +83,7 @@ obj.foo = 'string'
>obj.foo : string | undefined
> : ^^^^^^^^^^^^^^^^^^
>obj : { [x: string]: string | number | ((arg0: number) => number) | undefined; foo: string | undefined; bar: string | undefined; method1(arg0: number): number; lol: string; arrowFunc: (arg0: number) => number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^ ^^ ^^^
>foo : string | undefined
> : ^^^^^^^^^^^^^^^^^^
>'string' : "string"
@@ -93,7 +93,7 @@ obj.lol
>obj.lol : string
> : ^^^^^^
>obj : { [x: string]: string | number | ((arg0: number) => number) | undefined; foo: string | undefined; bar: string | undefined; method1(arg0: number): number; lol: string; arrowFunc: (arg0: number) => number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^ ^^ ^^^
>lol : string
> : ^^^^^^
@@ -103,7 +103,7 @@ obj.bar = undefined;
>obj.bar : string | undefined
> : ^^^^^^^^^^^^^^^^^^
>obj : { [x: string]: string | number | ((arg0: number) => number) | undefined; foo: string | undefined; bar: string | undefined; method1(arg0: number): number; lol: string; arrowFunc: (arg0: number) => number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^ ^^ ^^^
>bar : string | undefined
> : ^^^^^^^^^^^^^^^^^^
>undefined : undefined
@@ -117,7 +117,7 @@ var k = obj.method1(0);
>obj.method1 : (arg0: number) => number
> : ^^^^^^^ ^^^^^
>obj : { [x: string]: string | number | ((arg0: number) => number) | undefined; foo: string | undefined; bar: string | undefined; method1(arg0: number): number; lol: string; arrowFunc: (arg0: number) => number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^ ^^ ^^^
>method1 : (arg0: number) => number
> : ^^^^^^^ ^^^^^
>0 : 0
@@ -129,7 +129,7 @@ obj.bar1 = "42";
>obj.bar1 : string | number | ((arg0: number) => number) | undefined
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^
>obj : { [x: string]: string | number | ((arg0: number) => number) | undefined; foo: string | undefined; bar: string | undefined; method1(arg0: number): number; lol: string; arrowFunc: (arg0: number) => number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^ ^^ ^^^
>bar1 : string | number | ((arg0: number) => number) | undefined
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^
>"42" : "42"
@@ -141,7 +141,7 @@ obj.arrowFunc(0);
>obj.arrowFunc : (arg0: number) => number
> : ^^^^^^^ ^^^^^
>obj : { [x: string]: string | number | ((arg0: number) => number) | undefined; foo: string | undefined; bar: string | undefined; method1(arg0: number): number; lol: string; arrowFunc: (arg0: number) => number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^ ^^ ^^^
>arrowFunc : (arg0: number) => number
> : ^^^^^^^ ^^^^^
>0 : 0
tests/baselines/reference/checkJsdocTypeTagOnObjectProperty2.types
+4 -4
View File
@@ -8,9 +8,9 @@ var lol;
const obj = {
>obj : { bar: string | undefined; method1(arg0: number): number; method2: (arg0: number) => number; arrowFunc: (arg0: number) => number; lol: string; }
> : ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^ ^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^^^^^ ^^^
>{ /** @type {string|undefined} */ bar: 42, /** @type {function(number): number} */ method1(n1) { return "42"; }, /** @type {function(number): number} */ method2: (n1) => "lol", /** @type {function(number): number} */ arrowFunc: (num="0") => num + 42, /** @type {string} */ lol} : { bar: string | undefined; method1(arg0: number): number; method2: (arg0: number) => number; arrowFunc: (arg0: number) => number; lol: string; }
> : ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^ ^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^^^^^ ^^^
/** @type {string|undefined} */
bar: 42,
@@ -81,7 +81,7 @@ var s = obj.method1(0);
>obj.method1 : (arg0: number) => number
> : ^^^^^^^ ^^^^^
>obj : { bar: string | undefined; method1(arg0: number): number; method2: (arg0: number) => number; arrowFunc: (arg0: number) => number; lol: string; }
> : ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^ ^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^^^^^ ^^^
>method1 : (arg0: number) => number
> : ^^^^^^^ ^^^^^
>0 : 0
@@ -96,7 +96,7 @@ var s1 = obj.method2("0");
>obj.method2 : (arg0: number) => number
> : ^^^^^^^ ^^^^^
>obj : { bar: string | undefined; method1(arg0: number): number; method2: (arg0: number) => number; arrowFunc: (arg0: number) => number; lol: string; }
> : ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^ ^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^^^^^ ^^^
>method2 : (arg0: number) => number
> : ^^^^^^^ ^^^^^
>"0" : "0"
tests/baselines/reference/circularBaseConstraint.types
+1 -1
View File
@@ -23,7 +23,7 @@ type B<T> = T extends any[]
function foo<T>() {
>foo : <T>() => void
> : ^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^
`${a}` as B<T>;
>`${a}` as B<T> : B<T>
tests/baselines/reference/circularIndexedAccessErrors.types
+1 -1
View File
@@ -86,6 +86,6 @@ interface Foo {
function foo<T extends Foo | T["hello"]>() {
>foo : <T>() => void
> : ^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^
}
tests/baselines/reference/circularReferenceInReturnType.types
+1 -1
View File
@@ -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
tests/baselines/reference/circularReferenceInReturnType2.types
+1 -1
View File
@@ -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; }
tests/baselines/reference/circularlySimplifyingConditionalTypesNoCrash.types
+1 -1
View File
@@ -72,7 +72,7 @@ const myStoreConnect: Connect = function(
>myStoreConnect : Connect
> : ^^^^^^^
>function( mapStateToProps?: any, mapDispatchToProps?: any, mergeProps?: any, options: unknown = {},) { return connect( mapStateToProps, mapDispatchToProps, mergeProps, options, );} : <TStateProps, TOwnProps>(mapStateToProps?: any, mapDispatchToProps?: any, mergeProps?: any, options?: unknown) => InferableComponentEnhancerWithProps<TStateProps, Omit<P, Extract<keyof TStateProps, keyof P>> & TOwnProps>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
mapStateToProps?: any,
>mapStateToProps : any
tests/baselines/reference/classCanExtendConstructorFunction.types
+12 -12
View File
@@ -26,15 +26,15 @@ function Wagon(numberOxen) {
/** @param {Wagon[]=} wagons */
Wagon.circle = function (wagons) {
>Wagon.circle = function (wagons) { return wagons ? wagons.length : 3.14;} : (wagons?: Wagon[] | undefined) => number
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^
>Wagon.circle : (wagons?: Wagon[] | undefined) => number
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^
>Wagon : typeof Wagon
> : ^^^^^^^^^^^^
>circle : (wagons?: Wagon[] | undefined) => number
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^
>function (wagons) { return wagons ? wagons.length : 3.14;} : (wagons?: Wagon[] | undefined) => number
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^
>wagons : Wagon[]
> : ^^^^^^^
@@ -55,7 +55,7 @@ Wagon.circle = function (wagons) {
/** @param {*[]=} supplies - *[]= is my favourite type */
Wagon.prototype.load = function (supplies) {
>Wagon.prototype.load = function (supplies) {} : (supplies?: any[] | undefined) => void
> : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^
>Wagon.prototype.load : any
> : ^^^
>Wagon.prototype : any
@@ -67,14 +67,14 @@ Wagon.prototype.load = function (supplies) {
>load : any
> : ^^^
>function (supplies) {} : (supplies?: any[] | undefined) => void
> : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^
>supplies : any[]
> : ^^^^^
}
/** @param {*[]=} supplies - Yep, still a great type */
Wagon.prototype.weight = supplies => supplies ? supplies.length : -1
>Wagon.prototype.weight = supplies => supplies ? supplies.length : -1 : (supplies?: any[] | undefined) => number
> : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^
>Wagon.prototype.weight : any
> : ^^^
>Wagon.prototype : any
@@ -86,7 +86,7 @@ Wagon.prototype.weight = supplies => supplies ? supplies.length : -1
>weight : any
> : ^^^
>supplies => supplies ? supplies.length : -1 : (supplies?: any[] | undefined) => number
> : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^
>supplies : any[]
> : ^^^^^
>supplies ? supplies.length : -1 : number
@@ -132,11 +132,11 @@ Wagon.prototype.speed = function () {
>this.weight() : number
> : ^^^^^^
>this.weight : (supplies?: any[] | undefined) => number
> : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^
>this : this
> : ^^^^
>weight : (supplies?: any[] | undefined) => number
> : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^
}
// ok
class Sql extends Wagon {
@@ -210,11 +210,11 @@ class Sql extends Wagon {
>super.weight() : number
> : ^^^^^^
>super.weight : (supplies?: any[] | undefined) => number
> : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^
>super : Wagon
> : ^^^^^
>weight : (supplies?: any[] | undefined) => number
> : ^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^
>0 : 0
> : ^
tests/baselines/reference/classExpressionTest1.types
+3 -3
View File
@@ -11,7 +11,7 @@ function M() {
f<T>() {
>f : <T>() => { t: T; x: X; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
var t: T;
>t : T
@@ -43,9 +43,9 @@ function M() {
>v.f<string>() : { t: string; x: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>v.f : <T>() => { t: T; x: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>v : C<number>
> : ^^^^^^^^^
>f : <T>() => { t: T; x: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
}
tests/baselines/reference/classExpressionTest2.types
+3 -3
View File
@@ -15,7 +15,7 @@ function M() {
f<T>() {
>f : <T>() => { t: T; x: X; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
var t: T;
>t : T
@@ -47,9 +47,9 @@ function M() {
>v.f<string>() : { t: string; x: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>v.f : <T>() => { t: T; x: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>v : C<number>
> : ^^^^^^^^^
>f : <T>() => { t: T; x: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
}
tests/baselines/reference/classReferencedInContextualParameterWithinItsOwnBaseExpression.types
+1 -1
View File
@@ -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"
tests/baselines/reference/classStaticBlock23(target=es2022).types
+2 -2
View File
@@ -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
tests/baselines/reference/classStaticBlock23(target=esnext).types
+2 -2
View File
@@ -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
tests/baselines/reference/coAndContraVariantInferences3.types
+4 -4
View File
@@ -33,7 +33,7 @@ type OverloadBinder<T extends OverloadDefinitions> = (args: OverloadParameters<T
>OverloadBinder : OverloadBinder<T>
> : ^^^^^^^^^^^^^^^^^
>args : Parameters<{ [P in Extract<keyof T, number>]: T[P]; }[Extract<keyof T, number>]>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
type OverloadKeys<T extends OverloadDefinitions> = Extract<keyof T, number>;
>OverloadKeys : OverloadKeys<T>
@@ -246,7 +246,7 @@ declare const updateImportDeclaration: {
declare function every<T, U extends T>(array: readonly T[], callback: (element: T, index: number) => element is U): array is readonly U[];
>every : { <T, U extends T>(array: readonly T[], callback: (element: T, index: number) => element is U): array is readonly U[]; <T_1, U_1 extends T_1>(array: readonly T_1[] | undefined, callback: (element: T_1, index: number) => element is U_1): array is readonly U_1[] | undefined; <T_1>(array: readonly T_1[] | undefined, callback: (element: T_1, index: number) => boolean): boolean; }
> : ^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>array : readonly T[]
> : ^^^^^^^^^^^^
>callback : (element: T, index: number) => element is U
@@ -258,7 +258,7 @@ declare function every<T, U extends T>(array: readonly T[], callback: (element:
declare function every<T, U extends T>(array: readonly T[] | undefined, callback: (element: T, index: number) => element is U): array is readonly U[] | undefined;
>every : { <T_1, U_1 extends T_1>(array: readonly T_1[], callback: (element: T_1, index: number) => element is U_1): array is readonly U_1[]; <T, U extends T>(array: readonly T[] | undefined, callback: (element: T, index: number) => element is U): array is readonly U[] | undefined; <T_1>(array: readonly T_1[] | undefined, callback: (element: T_1, index: number) => boolean): boolean; }
> : ^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>array : readonly T[] | undefined
> : ^^^^^^^^^^^^^^^^^^^^^^^^
>callback : (element: T, index: number) => element is U
@@ -270,7 +270,7 @@ declare function every<T, U extends T>(array: readonly T[] | undefined, callback
declare function every<T>(array: readonly T[] | undefined, callback: (element: T, index: number) => boolean): boolean;
>every : { <T_1, U extends T_1>(array: readonly T_1[], callback: (element: T_1, index: number) => element is U): array is readonly U[]; <T_1, U extends T_1>(array: readonly T_1[] | undefined, callback: (element: T_1, index: number) => element is U): array is readonly U[] | undefined; <T>(array: readonly T[] | undefined, callback: (element: T, index: number) => boolean): boolean; }
> : ^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>array : readonly T[] | undefined
> : ^^^^^^^^^^^^^^^^^^^^^^^^
>callback : (element: T, index: number) => boolean
tests/baselines/reference/commaOperatorInConditionalExpression.types
+2 -2
View File
@@ -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
tests/baselines/reference/commaOperatorOtherInvalidOperation.types
+1 -1
View File
@@ -34,7 +34,7 @@ var resultIsString: number = foo(1, "123"); //error here
//TypeParameters
function foo1<T1, T2>() {
>foo1 : <T1, T2>() => void
> : ^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
var x: T1;
>x : T1
tests/baselines/reference/commaOperatorOtherValidOperation.types
+1 -1
View File
@@ -62,7 +62,7 @@ var resultIsString = foo(1, "123");
//TypeParameters
function foo1<T1, T2>()
>foo1 : <T1, T2>() => void
> : ^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
{
var x: T1;
>x : T1
tests/baselines/reference/commentInMethodCall.types
+2 -2
View File
@@ -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
tests/baselines/reference/complexRecursiveCollections.types
+17 -17
View File
@@ -41,7 +41,7 @@ interface Collection<K, V> {
// these seem necessary to push it over the top for memory usage
reduce<R>(reducer: (reduction: R, value: V, key: K, iter: this) => R, initialReduction: R, context?: any): R;
>reduce : { <R>(reducer: (reduction: R, value: V, key: K, iter: this) => R, initialReduction: R, context?: any): R; <R_1>(reducer: (reduction: V | R_1, value: V, key: K, iter: this) => R_1): R_1; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^ ^^^ ^^^
>reducer : (reduction: R, value: V, key: K, iter: this) => R
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>reduction : R
@@ -59,7 +59,7 @@ interface Collection<K, V> {
reduce<R>(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R;
>reduce : { <R_1>(reducer: (reduction: R_1, value: V, key: K, iter: this) => R_1, initialReduction: R_1, context?: any): R_1; <R>(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^
>reducer : (reduction: V | R, value: V, key: K, iter: this) => R
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>reduction : V | R
@@ -1325,7 +1325,7 @@ declare module Immutable {
zipWith<U, Z>(zipper: (value: T, otherValue: U) => Z, otherCollection: Collection<any, U>): OrderedSet<Z>;
>zipWith : { <U, Z>(zipper: (value: T, otherValue: U) => Z, otherCollection: Collection<any, U>): OrderedSet<Z>; <U_1, V, Z_1>(zipper: (value: T, otherValue: U_1, thirdValue: V) => Z_1, otherCollection: Collection<any, U_1>, thirdCollection: Collection<any, V>): OrderedSet<Z_1>; <Z_1>(zipper: (...any: Array<any>) => Z_1, ...collections: Array<Collection<any, any>>): OrderedSet<Z_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^^^^ ^^ ^^^ ^^^
>zipper : (value: T, otherValue: U) => Z
> : ^ ^^ ^^ ^^ ^^^^^
>value : T
@@ -1337,7 +1337,7 @@ declare module Immutable {
zipWith<U, V, Z>(zipper: (value: T, otherValue: U, thirdValue: V) => Z, otherCollection: Collection<any, U>, thirdCollection: Collection<any, V>): OrderedSet<Z>;
>zipWith : { <U_1, Z_1>(zipper: (value: T, otherValue: U_1) => Z_1, otherCollection: Collection<any, U_1>): OrderedSet<Z_1>; <U, V, Z>(zipper: (value: T, otherValue: U, thirdValue: V) => Z, otherCollection: Collection<any, U>, thirdCollection: Collection<any, V>): OrderedSet<Z>; <Z_1>(zipper: (...any: Array<any>) => Z_1, ...collections: Array<Collection<any, any>>): OrderedSet<Z_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^^^^ ^^ ^^^ ^^^
>zipper : (value: T, otherValue: U, thirdValue: V) => Z
> : ^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>value : T
@@ -1353,7 +1353,7 @@ declare module Immutable {
zipWith<Z>(zipper: (...any: Array<any>) => Z, ...collections: Array<Collection<any, any>>): OrderedSet<Z>;
>zipWith : { <U, Z_1>(zipper: (value: T, otherValue: U) => Z_1, otherCollection: Collection<any, U>): OrderedSet<Z_1>; <U, V, Z_1>(zipper: (value: T, otherValue: U, thirdValue: V) => Z_1, otherCollection: Collection<any, U>, thirdCollection: Collection<any, V>): OrderedSet<Z_1>; <Z>(zipper: (...any: Array<any>) => Z, ...collections: Array<Collection<any, any>>): OrderedSet<Z>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
>zipper : (...any: Array<any>) => Z
> : ^^^^ ^^ ^^^^^
>any : any[]
@@ -1813,7 +1813,7 @@ declare module Immutable {
export module Keyed {}
export function Keyed<K, V>(collection: Iterable<[K, V]>): Seq.Keyed<K, V>;
>Keyed : { <K, V>(collection: Iterable<[K, V]>): Seq.Keyed<K, V>; <V_1>(obj: { [key: string]: V_1; }): Seq.Keyed<string, V_1>; <K_1, V_1>(): Seq.Keyed<K_1, V_1>; (): Seq.Keyed<any, any>; }
> : ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^^^ ^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^ ^^^^^^ ^^^
>collection : Iterable<[K, V]>
> : ^^^^^^^^^^^^^^^^
>Seq : any
@@ -1821,7 +1821,7 @@ declare module Immutable {
export function Keyed<V>(obj: {[key: string]: V}): Seq.Keyed<string, V>;
>Keyed : { <K, V_1>(collection: Iterable<[K, V_1]>): Seq.Keyed<K, V_1>; <V>(obj: { [key: string]: V; }): Seq.Keyed<string, V>; <K, V_1>(): Seq.Keyed<K, V_1>; (): Seq.Keyed<any, any>; }
> : ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^^^ ^^^^^^ ^^^
> : ^^^ ^^^^^^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^ ^^^
>obj : { [key: string]: V; }
> : ^^^^^^^^^^^^^^^^^^^^^
>key : string
@@ -1831,7 +1831,7 @@ declare module Immutable {
export function Keyed<K, V>(): Seq.Keyed<K, V>;
>Keyed : { <K_1, V_1>(collection: Iterable<[K_1, V_1]>): Seq.Keyed<K_1, V_1>; <V_1>(obj: { [key: string]: V_1; }): Seq.Keyed<string, V_1>; <K, V>(): Seq.Keyed<K, V>; (): Seq.Keyed<any, any>; }
> : ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^^^ ^^^^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^^^ ^^ ^^^ ^^^ ^^ ^^^^^ ^^^^^^ ^^^
>Seq : any
> : ^^^
@@ -2372,7 +2372,7 @@ declare module Immutable {
export module Keyed {}
export function Keyed<K, V>(collection: Iterable<[K, V]>): Collection.Keyed<K, V>;
>Keyed : { <K, V>(collection: Iterable<[K, V]>): Collection.Keyed<K, V>; <V_1>(obj: { [key: string]: V_1; }): Collection.Keyed<string, V_1>; }
> : ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^^ ^^^
>collection : Iterable<[K, V]>
> : ^^^^^^^^^^^^^^^^
>Collection : any
@@ -2380,7 +2380,7 @@ declare module Immutable {
export function Keyed<V>(obj: {[key: string]: V}): Collection.Keyed<string, V>;
>Keyed : { <K, V_1>(collection: Iterable<[K, V_1]>): Collection.Keyed<K, V_1>; <V>(obj: { [key: string]: V; }): Collection.Keyed<string, V>; }
> : ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^^^^^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^
>obj : { [key: string]: V; }
> : ^^^^^^^^^^^^^^^^^^^^^
>key : string
@@ -2611,7 +2611,7 @@ declare module Immutable {
zipWith<U, Z>(zipper: (value: T, otherValue: U) => Z, otherCollection: Collection<any, U>): Collection.Indexed<Z>;
>zipWith : { <U, Z>(zipper: (value: T, otherValue: U) => Z, otherCollection: Collection<any, U>): Collection.Indexed<Z>; <U_1, V, Z_1>(zipper: (value: T, otherValue: U_1, thirdValue: V) => Z_1, otherCollection: Collection<any, U_1>, thirdCollection: Collection<any, V>): Collection.Indexed<Z_1>; <Z_1>(zipper: (...any: Array<any>) => Z_1, ...collections: Array<Collection<any, any>>): Collection.Indexed<Z_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^^^^ ^^ ^^^ ^^^
>zipper : (value: T, otherValue: U) => Z
> : ^ ^^ ^^ ^^ ^^^^^
>value : T
@@ -2625,7 +2625,7 @@ declare module Immutable {
zipWith<U, V, Z>(zipper: (value: T, otherValue: U, thirdValue: V) => Z, otherCollection: Collection<any, U>, thirdCollection: Collection<any, V>): Collection.Indexed<Z>;
>zipWith : { <U_1, Z_1>(zipper: (value: T, otherValue: U_1) => Z_1, otherCollection: Collection<any, U_1>): Collection.Indexed<Z_1>; <U, V, Z>(zipper: (value: T, otherValue: U, thirdValue: V) => Z, otherCollection: Collection<any, U>, thirdCollection: Collection<any, V>): Collection.Indexed<Z>; <Z_1>(zipper: (...any: Array<any>) => Z_1, ...collections: Array<Collection<any, any>>): Collection.Indexed<Z_1>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^^^^ ^^ ^^^ ^^^
>zipper : (value: T, otherValue: U, thirdValue: V) => Z
> : ^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>value : T
@@ -2643,7 +2643,7 @@ declare module Immutable {
zipWith<Z>(zipper: (...any: Array<any>) => Z, ...collections: Array<Collection<any, any>>): Collection.Indexed<Z>;
>zipWith : { <U, Z_1>(zipper: (value: T, otherValue: U) => Z_1, otherCollection: Collection<any, U>): Collection.Indexed<Z_1>; <U, V, Z_1>(zipper: (value: T, otherValue: U, thirdValue: V) => Z_1, otherCollection: Collection<any, U>, thirdCollection: Collection<any, V>): Collection.Indexed<Z_1>; <Z>(zipper: (...any: Array<any>) => Z, ...collections: Array<Collection<any, any>>): Collection.Indexed<Z>; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
>zipper : (...any: Array<any>) => Z
> : ^^^^ ^^ ^^^^^
>any : any[]
@@ -3338,7 +3338,7 @@ declare module Immutable {
// Reducing a value
reduce<R>(reducer: (reduction: R, value: V, key: K, iter: this) => R, initialReduction: R, context?: any): R;
>reduce : { <R>(reducer: (reduction: R, value: V, key: K, iter: this) => R, initialReduction: R, context?: any): R; <R_1>(reducer: (reduction: V | R_1, value: V, key: K, iter: this) => R_1): R_1; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^ ^^^ ^^^
>reducer : (reduction: R, value: V, key: K, iter: this) => R
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>reduction : R
@@ -3356,7 +3356,7 @@ declare module Immutable {
reduce<R>(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R;
>reduce : { <R_1>(reducer: (reduction: R_1, value: V, key: K, iter: this) => R_1, initialReduction: R_1, context?: any): R_1; <R>(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^
>reducer : (reduction: V | R, value: V, key: K, iter: this) => R
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>reduction : V | R
@@ -3370,7 +3370,7 @@ declare module Immutable {
reduceRight<R>(reducer: (reduction: R, value: V, key: K, iter: this) => R, initialReduction: R, context?: any): R;
>reduceRight : { <R>(reducer: (reduction: R, value: V, key: K, iter: this) => R, initialReduction: R, context?: any): R; <R_1>(reducer: (reduction: V | R_1, value: V, key: K, iter: this) => R_1): R_1; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^ ^^^ ^^^
>reducer : (reduction: R, value: V, key: K, iter: this) => R
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>reduction : R
@@ -3388,7 +3388,7 @@ declare module Immutable {
reduceRight<R>(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R;
>reduceRight : { <R_1>(reducer: (reduction: R_1, value: V, key: K, iter: this) => R_1, initialReduction: R_1, context?: any): R_1; <R>(reducer: (reduction: V | R, value: V, key: K, iter: this) => R): R; }
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^
> : ^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^
>reducer : (reduction: V | R, value: V, key: K, iter: this) => R
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>reduction : V | R
tests/baselines/reference/computedPropertyNames32_ES5.types
+2 -2
View File
@@ -3,7 +3,7 @@
=== computedPropertyNames32_ES5.ts ===
function foo<T>() { return '' }
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
>'' : ""
> : ^^
@@ -25,5 +25,5 @@ class C<T> {
>foo<T>() : string
> : ^^^^^^
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
}
tests/baselines/reference/computedPropertyNames32_ES6.types
+2 -2
View File
@@ -3,7 +3,7 @@
=== computedPropertyNames32_ES6.ts ===
function foo<T>() { return '' }
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
>'' : ""
> : ^^
@@ -25,5 +25,5 @@ class C<T> {
>foo<T>() : string
> : ^^^^^^
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
}
tests/baselines/reference/computedPropertyNames33_ES5.types
+1 -1
View File
@@ -3,7 +3,7 @@
=== computedPropertyNames33_ES5.ts ===
function foo<T>() { return '' }
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
>'' : ""
> : ^^
tests/baselines/reference/computedPropertyNames33_ES6.types
+1 -1
View File
@@ -3,7 +3,7 @@
=== computedPropertyNames33_ES6.ts ===
function foo<T>() { return '' }
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
>'' : ""
> : ^^
tests/baselines/reference/computedPropertyNames34_ES5.types
+2 -2
View File
@@ -3,7 +3,7 @@
=== computedPropertyNames34_ES5.ts ===
function foo<T>() { return '' }
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
>'' : ""
> : ^^
@@ -27,7 +27,7 @@ class C<T> {
>foo<T>() : string
> : ^^^^^^
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
};
return 0;
tests/baselines/reference/computedPropertyNames34_ES6.types
+2 -2
View File
@@ -3,7 +3,7 @@
=== computedPropertyNames34_ES6.ts ===
function foo<T>() { return '' }
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
>'' : ""
> : ^^
@@ -27,7 +27,7 @@ class C<T> {
>foo<T>() : string
> : ^^^^^^
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
};
return 0;
tests/baselines/reference/computedPropertyNames35_ES5.types
+2 -2
View File
@@ -3,7 +3,7 @@
=== computedPropertyNames35_ES5.ts ===
function foo<T>() { return '' }
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
>'' : ""
> : ^^
@@ -18,5 +18,5 @@ interface I<T> {
>foo<T>() : string
> : ^^^^^^
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
}
tests/baselines/reference/computedPropertyNames35_ES6.types
+2 -2
View File
@@ -3,7 +3,7 @@
=== computedPropertyNames35_ES6.ts ===
function foo<T>() { return '' }
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
>'' : ""
> : ^^
@@ -18,5 +18,5 @@ interface I<T> {
>foo<T>() : string
> : ^^^^^^
>foo : <T>() => string
> : ^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^
}
tests/baselines/reference/computedPropertyNames51_ES5.types
+1 -1
View File
@@ -3,7 +3,7 @@
=== computedPropertyNames51_ES5.ts ===
function f<T, K extends keyof T>() {
>f : <T, K extends keyof T>() => void
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^^^^^
var t: T;
>t : T
tests/baselines/reference/computedPropertyNames51_ES6.types
+1 -1
View File
@@ -3,7 +3,7 @@
=== computedPropertyNames51_ES6.ts ===
function f<T, K extends keyof T>() {
>f : <T, K extends keyof T>() => void
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^^^^^
var t: T;
>t : T
tests/baselines/reference/computedPropertyNames8_ES5.types
+1 -1
View File
@@ -3,7 +3,7 @@
=== computedPropertyNames8_ES5.ts ===
function f<T, U extends string>() {
>f : <T, U extends string>() => void
> : ^^^^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^^^^^
var t: T;
>t : T
tests/baselines/reference/computedPropertyNames8_ES6.types
+1 -1
View File
@@ -3,7 +3,7 @@
=== computedPropertyNames8_ES6.ts ===
function f<T, U extends string>() {
>f : <T, U extends string>() => void
> : ^^^^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^^^^^
var t: T;
>t : T
tests/baselines/reference/computedTypesKeyofNoIndexSignatureType.types
+1 -1
View File
@@ -3,7 +3,7 @@
=== computedTypesKeyofNoIndexSignatureType.ts ===
type Compute<A> = { [K in keyof A]: Compute<A[K]>; } & {};
>Compute : { [K in keyof A]: A[K] extends infer T ? { [K_1 in keyof T]: A[K][K_1] extends infer T_1 ? { [K_2 in keyof T_1]: A[K][K_1][K_2] extends infer T_2 ? { [K_3 in keyof T_2]: A[K][K_1][K_2][K_3] extends infer T_3 ? { [K_4 in keyof T_3]: A[K][K_1][K_2][K_3][K_4] extends infer T_4 ? { [K_5 in keyof T_4]: A[K][K_1][K_2][K_3][K_4][K_5] extends infer T_5 ? { [K_6 in keyof T_5]: A[K][K_1][K_2][K_3][K_4][K_5][K_6] extends infer T_6 ? { [K_7 in keyof T_6]: A[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7] extends infer T_7 ? { [K_8 in keyof T_7]: A[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8] extends infer T_8 ? { [K_9 in keyof T_8]: A[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9] extends infer T_9 ? { [K_10 in keyof T_9]: any; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; } : never; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
type EqualsTest<T> = <A>() => A extends T ? 1 : 0;
>EqualsTest : EqualsTest<T>
tests/baselines/reference/conditionalTypeAssignabilityWhenDeferred.types
+4 -4
View File
@@ -135,7 +135,7 @@ function f<T>(t: T) {
>onlyNullablePlease(x) : void
> : ^^^^
>onlyNullablePlease : <T_1 extends null extends T_1 ? any : never>(value: T_1) => void
> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^^^^
>x : T | null
> : ^^^^^^^^
@@ -143,7 +143,7 @@ function f<T>(t: T) {
>onlyNullablePlease2(x) : void
> : ^^^^
>onlyNullablePlease2 : <T_1 extends [null] extends [T_1] ? any : never>(value: T_1) => void
> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^^^^
>x : T | null
> : ^^^^^^^^
}
@@ -225,7 +225,7 @@ type Distributive<T> = T extends { a: number } ? { a: number } : { b: number };
function testAssignabilityToConditionalType<T>() {
>testAssignabilityToConditionalType : <T>() => void
> : ^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^
const o = { a: 1, b: 2 };
>o : { a: number; b: number; }
@@ -292,7 +292,7 @@ function testAssignabilityToConditionalType<T>() {
// Infer type parameters: no good
const o2: [T] extends [[infer U]] ? U : { b: number } = o;
>o2 : [T] extends [[infer U]] ? U : { b: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^
>b : number
> : ^^^^^^
>o : { a: number; b: number; }
tests/baselines/reference/conditionalTypeContextualTypeSimplificationsSuceeds.types
+3 -3
View File
@@ -16,7 +16,7 @@ function bad<P extends Props>(
attrs: string extends keyof P ? { [K in keyof P]: P[K] } : { [K in keyof P]: P[K] }) { }
>attrs : string extends keyof P ? { [K in keyof P]: P[K]; } : { [K_1 in keyof P]: P[K_1]; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
function good1<P extends Props>(
>good1 : <P extends Props>(attrs: string extends keyof P ? P : { [K in keyof P]: P[K]; }) => void
@@ -24,7 +24,7 @@ function good1<P extends Props>(
attrs: string extends keyof P ? P : { [K in keyof P]: P[K] }) { }
>attrs : string extends keyof P ? P : { [K in keyof P]: P[K]; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
function good2<P extends Props>(
>good2 : <P extends Props>(attrs: { [K in keyof P]: P[K]; }) => void
@@ -32,7 +32,7 @@ function good2<P extends Props>(
attrs: { [K in keyof P]: P[K] }) { }
>attrs : { [K in keyof P]: P[K]; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^
bad({ when: value => false });
>bad({ when: value => false }) : void
tests/baselines/reference/conditionalTypeDoesntSpinForever.types
+16 -16
View File
@@ -104,7 +104,7 @@ export enum PubSubRecordIsStoredInRedisAsA {
>buildPubSubRecordType(Object.assign({}, soFar, {name: instance as TYPE}) as SO_FAR & {name: TYPE}) : BuildPubSubRecordType<SO_FAR & { name: TYPE; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
>buildPubSubRecordType : <SO_FAR_1>(soFar: SO_FAR_1) => BuildPubSubRecordType<SO_FAR_1>
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^ ^^ ^^^^^
>Object.assign({}, soFar, {name: instance as TYPE}) as SO_FAR & {name: TYPE} : SO_FAR & { name: TYPE; }
> : ^^^^^^^^^^^^^^^^^ ^^^
>Object.assign({}, soFar, {name: instance as TYPE}) : SO_FAR & { name: TYPE; }
@@ -195,7 +195,7 @@ export enum PubSubRecordIsStoredInRedisAsA {
>buildPubSubRecordType(Object.assign({}, soFar, {storedAs: PubSubRecordIsStoredInRedisAsA.jsonEncodedRedisString})) : BuildPubSubRecordType<SO_FAR & { storedAs: PubSubRecordIsStoredInRedisAsA; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>buildPubSubRecordType : <SO_FAR_1>(soFar: SO_FAR_1) => BuildPubSubRecordType<SO_FAR_1>
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^ ^^ ^^^^^
>Object.assign({}, soFar, {storedAs: PubSubRecordIsStoredInRedisAsA.jsonEncodedRedisString}) : SO_FAR & { storedAs: PubSubRecordIsStoredInRedisAsA; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Object.assign : { <T extends {}, U>(target: T, source: U): T & U; <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V; <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W; (target: object, ...sources: any[]): any; }
@@ -237,7 +237,7 @@ export enum PubSubRecordIsStoredInRedisAsA {
>buildPubSubRecordType(Object.assign({}, soFar, {storedAs: PubSubRecordIsStoredInRedisAsA.redisHash})) : BuildPubSubRecordType<SO_FAR & { storedAs: PubSubRecordIsStoredInRedisAsA; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>buildPubSubRecordType : <SO_FAR_1>(soFar: SO_FAR_1) => BuildPubSubRecordType<SO_FAR_1>
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^ ^^ ^^^^^
>Object.assign({}, soFar, {storedAs: PubSubRecordIsStoredInRedisAsA.redisHash}) : SO_FAR & { storedAs: PubSubRecordIsStoredInRedisAsA; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Object.assign : { <T extends {}, U>(target: T, source: U): T & U; <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V; <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W; (target: object, ...sources: any[]): any; }
@@ -345,7 +345,7 @@ export enum PubSubRecordIsStoredInRedisAsA {
>buildPubSubRecordType(Object.assign({}, soFar, {identifier: instance as TYPE}) as SO_FAR & {identifier: TYPE}) : BuildPubSubRecordType<SO_FAR & { identifier: TYPE; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
>buildPubSubRecordType : <SO_FAR_1>(soFar: SO_FAR_1) => BuildPubSubRecordType<SO_FAR_1>
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^ ^^ ^^^^^
>Object.assign({}, soFar, {identifier: instance as TYPE}) as SO_FAR & {identifier: TYPE} : SO_FAR & { identifier: TYPE; }
> : ^^^^^^^^^^^^^^^^^^^^^^^ ^^^
>Object.assign({}, soFar, {identifier: instance as TYPE}) : SO_FAR & Record<"record", unknown> & { identifier: TYPE; }
@@ -432,7 +432,7 @@ export enum PubSubRecordIsStoredInRedisAsA {
>buildPubSubRecordType(Object.assign({}, soFar, {record: instance as TYPE}) as SO_FAR & {record: TYPE}) : BuildPubSubRecordType<SO_FAR & { record: TYPE; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^
>buildPubSubRecordType : <SO_FAR_1>(soFar: SO_FAR_1) => BuildPubSubRecordType<SO_FAR_1>
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^ ^^ ^^^^^
>Object.assign({}, soFar, {record: instance as TYPE}) as SO_FAR & {record: TYPE} : SO_FAR & { record: TYPE; }
> : ^^^^^^^^^^^^^^^^^^^ ^^^
>Object.assign({}, soFar, {record: instance as TYPE}) : SO_FAR & { record: TYPE; }
@@ -527,7 +527,7 @@ export enum PubSubRecordIsStoredInRedisAsA {
>buildPubSubRecordType(Object.assign({}, soFar, {maxMsToWaitBeforePublishing: instance})) : BuildPubSubRecordType<SO_FAR & { maxMsToWaitBeforePublishing: number; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>buildPubSubRecordType : <SO_FAR_1>(soFar: SO_FAR_1) => BuildPubSubRecordType<SO_FAR_1>
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^ ^^ ^^^^^
>Object.assign({}, soFar, {maxMsToWaitBeforePublishing: instance}) : SO_FAR & { maxMsToWaitBeforePublishing: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Object.assign : { <T extends {}, U>(target: T, source: U): T & U; <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V; <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W; (target: object, ...sources: any[]): any; }
@@ -561,7 +561,7 @@ export enum PubSubRecordIsStoredInRedisAsA {
>buildPubSubRecordType(Object.assign({}, soFar, {maxMsToWaitBeforePublishing: 0})) : BuildPubSubRecordType<SO_FAR & { maxMsToWaitBeforePublishing: number; }>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>buildPubSubRecordType : <SO_FAR_1>(soFar: SO_FAR_1) => BuildPubSubRecordType<SO_FAR_1>
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^ ^^ ^^^^^
>Object.assign({}, soFar, {maxMsToWaitBeforePublishing: 0}) : SO_FAR & { maxMsToWaitBeforePublishing: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Object.assign : { <T extends {}, U>(target: T, source: U): T & U; <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V; <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W; (target: object, ...sources: any[]): any; }
@@ -742,25 +742,25 @@ export enum PubSubRecordIsStoredInRedisAsA {
buildNameFieldConstructor(soFar),
>buildNameFieldConstructor(soFar) : { name?: undefined; } | { name: <TYPE>(instance?: TYPE) => BuildPubSubRecordType<SO_FAR & { name: TYPE; }>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>buildNameFieldConstructor : <SO_FAR_1>(soFar: SO_FAR_1) => { name?: undefined; } | { name: <TYPE>(instance?: TYPE) => BuildPubSubRecordType<SO_FAR_1 & { name: TYPE; }>; }
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^
> : ^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^
>soFar : SO_FAR
> : ^^^^^^
buildIdentifierFieldConstructor(soFar),
>buildIdentifierFieldConstructor(soFar) : { identifier?: undefined; } | { identifier: <TYPE>(instance?: TYPE) => BuildPubSubRecordType<SO_FAR & { identifier: TYPE; }>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>buildIdentifierFieldConstructor : <SO_FAR_1>(soFar: SO_FAR_1) => { identifier?: undefined; } | { identifier: <TYPE>(instance?: TYPE) => BuildPubSubRecordType<SO_FAR_1 & { identifier: TYPE; }>; }
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^
> : ^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^
>soFar : SO_FAR
> : ^^^^^^
buildRecordFieldConstructor(soFar),
>buildRecordFieldConstructor(soFar) : { record?: undefined; } | { record: <TYPE>(instance?: TYPE) => BuildPubSubRecordType<SO_FAR & { record: TYPE; }>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>buildRecordFieldConstructor : <SO_FAR_1>(soFar: SO_FAR_1) => { record?: undefined; } | { record: <TYPE>(instance?: TYPE) => BuildPubSubRecordType<SO_FAR_1 & { record: TYPE; }>; }
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^
> : ^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ^^^
>soFar : SO_FAR
> : ^^^^^^
@@ -768,7 +768,7 @@ export enum PubSubRecordIsStoredInRedisAsA {
>buildStoredAsConstructor(soFar) : { storedAsJsonEncodedRedisString?: undefined; storedAsRedisHash?: undefined; } | { storedAsJsonEncodedRedisString: () => BuildPubSubRecordType<SO_FAR & { storedAs: PubSubRecordIsStoredInRedisAsA.jsonEncodedRedisString; }>; storedAsRedisHash: () => BuildPubSubRecordType<SO_FAR & { storedAs: PubSubRecordIsStoredInRedisAsA.redisHash; }>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^
>buildStoredAsConstructor : <SO_FAR_1>(soFar: SO_FAR_1) => { storedAsJsonEncodedRedisString?: undefined; storedAsRedisHash?: undefined; } | { storedAsJsonEncodedRedisString: () => BuildPubSubRecordType<SO_FAR_1 & { storedAs: PubSubRecordIsStoredInRedisAsA.jsonEncodedRedisString; }>; storedAsRedisHash: () => BuildPubSubRecordType<SO_FAR_1 & { storedAs: PubSubRecordIsStoredInRedisAsA.redisHash; }>; }
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
> : ^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^
>soFar : SO_FAR
> : ^^^^^^
@@ -776,7 +776,7 @@ export enum PubSubRecordIsStoredInRedisAsA {
>buildMaxMsToWaitBeforePublishingFieldConstructor(soFar) : MaxMsToWaitBeforePublishingFieldConstructor<SO_FAR>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>buildMaxMsToWaitBeforePublishingFieldConstructor : <SO_FAR_1>(soFar: SO_FAR_1) => MaxMsToWaitBeforePublishingFieldConstructor<SO_FAR_1>
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^ ^^ ^^^^^
>soFar : SO_FAR
> : ^^^^^^
@@ -784,7 +784,7 @@ export enum PubSubRecordIsStoredInRedisAsA {
>buildType(soFar) : { type?: undefined; fields?: undefined; hasField?: undefined; } | { type: SO_FAR; fields: () => Set<keyof SO_FAR>; hasField: (fieldName: string | number | symbol) => boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^
>buildType : <SO_FAR_1>(soFar: SO_FAR_1) => { type?: undefined; fields?: undefined; hasField?: undefined; } | { type: SO_FAR_1; fields: () => Set<keyof SO_FAR_1>; hasField: (fieldName: string | number | symbol) => boolean; }
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^
>soFar : SO_FAR
> : ^^^^^^
tests/baselines/reference/conditionalTypes1.types
+16 -16
View File
@@ -673,7 +673,7 @@ function f20<T extends string>(n: number, b: boolean, x: number | boolean, y: T)
>zeroOf(5) : 0
> : ^
>zeroOf : <T_1 extends number | string | boolean>(value: T_1) => ZeroOf<T_1>
> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^^^^
>5 : 5
> : ^
@@ -681,7 +681,7 @@ function f20<T extends string>(n: number, b: boolean, x: number | boolean, y: T)
>zeroOf("hello") : ""
> : ^^
>zeroOf : <T_1 extends number | string | boolean>(value: T_1) => ZeroOf<T_1>
> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^^^^
>"hello" : "hello"
> : ^^^^^^^
@@ -689,7 +689,7 @@ function f20<T extends string>(n: number, b: boolean, x: number | boolean, y: T)
>zeroOf(true) : false
> : ^^^^^
>zeroOf : <T_1 extends number | string | boolean>(value: T_1) => ZeroOf<T_1>
> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^^^^
>true : true
> : ^^^^
@@ -697,7 +697,7 @@ function f20<T extends string>(n: number, b: boolean, x: number | boolean, y: T)
>zeroOf(n) : 0
> : ^
>zeroOf : <T_1 extends number | string | boolean>(value: T_1) => ZeroOf<T_1>
> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^^^^
>n : number
> : ^^^^^^
@@ -705,7 +705,7 @@ function f20<T extends string>(n: number, b: boolean, x: number | boolean, y: T)
>zeroOf(b) : false
> : ^^^^^
>zeroOf : <T_1 extends number | string | boolean>(value: T_1) => ZeroOf<T_1>
> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^^^^
>b : boolean
> : ^^^^^^^
@@ -713,7 +713,7 @@ function f20<T extends string>(n: number, b: boolean, x: number | boolean, y: T)
>zeroOf(x) : false | 0
> : ^^^^^^^^^
>zeroOf : <T_1 extends number | string | boolean>(value: T_1) => ZeroOf<T_1>
> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^^^^
>x : number | boolean
> : ^^^^^^^^^^^^^^^^
@@ -721,7 +721,7 @@ function f20<T extends string>(n: number, b: boolean, x: number | boolean, y: T)
>zeroOf(y) : ZeroOf<T>
> : ^^^^^^^^^
>zeroOf : <T_1 extends number | string | boolean>(value: T_1) => ZeroOf<T_1>
> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^
> : ^^^^^^^^^^^^^ ^^ ^^ ^^^^^
>y : T
> : ^
}
@@ -1033,7 +1033,7 @@ function f22<T>(x: T extends (infer U)[] ? U[] : never) {
>f22 : <T>(x: T extends (infer U)[] ? U[] : never) => void
> : ^ ^^ ^^ ^^^^^^^^^
>x : T extends (infer U)[] ? U[] : never
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
let e = x[0]; // {}
>e : unknown
@@ -1041,7 +1041,7 @@ function f22<T>(x: T extends (infer U)[] ? U[] : never) {
>x[0] : unknown
> : ^^^^^^^
>x : T extends (infer U)[] ? U[] : never
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
>0 : 0
> : ^
}
@@ -1050,7 +1050,7 @@ function f23<T extends string[]>(x: T extends (infer U)[] ? U[] : never) {
>f23 : <T extends string[]>(x: T extends (infer U)[] ? U[] : never) => void
> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^
>x : T extends (infer U)[] ? U[] : never
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
let e = x[0]; // string
>e : string
@@ -1058,7 +1058,7 @@ function f23<T extends string[]>(x: T extends (infer U)[] ? U[] : never) {
>x[0] : string
> : ^^^^^^
>x : T extends (infer U)[] ? U[] : never
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
>0 : 0
> : ^
}
@@ -1227,7 +1227,7 @@ const convert2 = <T>(value: Foo<T>): Baz<T> => value;
function f31<T>() {
>f31 : <T>() => void
> : ^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^
type T1 = T extends string ? boolean : number;
>T1 : T extends string ? boolean : number
@@ -1248,7 +1248,7 @@ function f31<T>() {
function f32<T, U>() {
>f32 : <T, U>() => void
> : ^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
type T1 = T & U extends string ? boolean : number;
>T1 : T & U extends string ? boolean : number
@@ -1269,7 +1269,7 @@ function f32<T, U>() {
function f33<T, U>() {
>f33 : <T, U>() => void
> : ^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
type T1 = Foo<T & U>;
>T1 : Foo<T & U>
@@ -1400,11 +1400,11 @@ function f50() {
type Omit<T extends object> = { [P in keyof T]: If<Eq<T[P], never>, never, P>; }[keyof T];
>Omit : { [P in keyof T]: (T[P] extends infer T_1 ? T_1 extends T[P] ? T_1 extends never ? never : false : never : never) extends infer T_2 ? T_2 extends (T[P] extends infer T_1 ? T_1 extends T[P] ? T_1 extends never ? never : false : never : never) ? T_2 extends false ? P : never : never : never; }[keyof T]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
type Omit2<T extends object, U = never> = { [P in keyof T]: If<Eq<T[P], U>, never, P>; }[keyof T];
>Omit2 : { [P in keyof T]: (T[P] extends infer T_1 ? T_1 extends T[P] ? T_1 extends U ? U extends T_1 ? true : false : false : never : never) extends infer T_2 ? T_2 extends (T[P] extends infer T_1 ? T_1 extends T[P] ? T_1 extends U ? U extends T_1 ? true : false : false : never : never) ? T_2 extends false ? P : never : never : never; }[keyof T]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
type A = Omit<{ a: void; b: never; }>; // 'a'
>A : "a"
tests/baselines/reference/conditionalTypes2.types
+5 -5
View File
@@ -122,7 +122,7 @@ function getFunction<T>(item: T) {
>isFunction(item) : boolean
> : ^^^^^^^
>isFunction : <T_1>(value: T_1) => value is Extract<T_1, Function>
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^ ^^ ^^^^^
>item : T
> : ^
@@ -147,7 +147,7 @@ function f10<T>(x: T) {
>isFunction(x) : boolean
> : ^^^^^^^
>isFunction : <T_1>(value: T_1) => value is Extract<T_1, Function>
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^ ^^ ^^^^^
>x : T
> : ^
@@ -372,7 +372,7 @@ class Vector<T> implements Seq<T> {
partition2<U extends T>(predicate:(v:T)=>boolean): [Vector<U>,Vector<any>] {
>partition2 : { <U_1 extends T>(predicate: (v: T) => v is U_1): [Vector<U_1>, Vector<Exclude<T, U_1>>]; (predicate: (x: T) => boolean): [Vector<T>, Vector<T>]; }
> : ^^^ ^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^
>predicate : (v: T) => boolean
> : ^ ^^ ^^^^^
>v : T
@@ -430,7 +430,7 @@ function foo<T>(value: T) {
>isFunction(value) : boolean
> : ^^^^^^^
>isFunction : <T_1>(value: T_1) => value is Extract<T_1, Function>
> : ^ ^^ ^^ ^^^^^
> : ^^^^^^ ^^ ^^^^^
>value : T
> : ^
@@ -761,7 +761,7 @@ type Wat<K extends string> = { x: { y: 0, z: 1 } } extends { x: { [P in K]: 0 }
>z : 1
> : ^
>x : { [P in K]: 0; }
> : ^^^^^^^^^^^^^^^^
> : ^^^ ^^^^^^^^^^^^
>true : true
> : ^^^^
>false : false
tests/baselines/reference/constraintReferencingTypeParameterFromSameTypeParameterList.types
+3 -3
View File
@@ -7,7 +7,7 @@ interface IComparable<T> {
}
function f<T, I extends IComparable<T>>() {
>f : <T, I extends IComparable<T>>() => void
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^^^^^
}
interface I1<T, U extends I1<T, any>> { // Error, any does not satisfy the constraint I1<T, any>
@@ -22,12 +22,12 @@ interface I4<T, U extends () => T> {
interface I3<T, U extends string> {
method1<X, Y extends T>();
>method1 : <X, Y extends T>() => any
> : ^^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^^^^
}
function foo<T, U extends <V extends T>(v: V) => void>() {
>foo : <T, U extends <V extends T>(v: V) => void>() => void
> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^ ^^^^^^^^^^^
>v : V
> : ^
}
tests/baselines/reference/constructorFunctionMethodTypeParameters.types
+4 -4
View File
@@ -103,11 +103,11 @@ const s = c.topLevelComment('a', 'b');
>c.topLevelComment('a', 'b') : "b"
> : ^^^
>c.topLevelComment : <V extends string>(t: "a", v: V) => V
> : ^^^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^
>c : Cls<"a">
> : ^^^^^^^^
>topLevelComment : <V extends string>(t: "a", v: V) => V
> : ^^^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^
>'a' : "a"
> : ^^^
>'b' : "b"
@@ -119,11 +119,11 @@ const t = c.nestedComment('a', 'b');
>c.nestedComment('a', 'b') : "a"
> : ^^^
>c.nestedComment : <U extends string>(t: "a", u: U) => "a"
> : ^^^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^^^
> : ^ ^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^^^
>c : Cls<"a">
> : ^^^^^^^^
>nestedComment : <U extends string>(t: "a", u: U) => "a"
> : ^^^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^^^
> : ^ ^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^^^
>'a' : "a"
> : ^^^
>'b' : "b"
tests/baselines/reference/constructorTypeWithTypeParameters.types
+2 -2
View File
@@ -3,7 +3,7 @@
=== constructorTypeWithTypeParameters.ts ===
declare var X: {
>X : new <T>() => number
> : ^^^^^^^^^^^^^
> : ^^^^^ ^^^^^^^
new <T>(): number;
}
@@ -15,5 +15,5 @@ declare var Y: {
}
var anotherVar: new <T>() => number;
>anotherVar : new <T>() => number
> : ^^^^^^^^^^^^^
> : ^^^^^ ^^^^^^^
tests/baselines/reference/contextualComputedNonBindablePropertyType.types
+1 -1
View File
@@ -11,7 +11,7 @@ declare function forceMatch<T>(matched: {
>forceMatch : <T>(matched: { [key in keyof T]: key; }) => void
> : ^ ^^ ^^ ^^^^^
>matched : { [key in keyof T]: key; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^^^^^^^^^^^^^^^^^^^
[key in keyof T]: key;
}): void;
tests/baselines/reference/contextualOverloadListFromArrayUnion.types
+4 -4
View File
@@ -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[]
tests/baselines/reference/contextualSignatureInstantiation1.types
+4 -4
View File
@@ -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
tests/baselines/reference/contextualSignatureInstantiation2.types
+3 -3
View File
@@ -58,11 +58,11 @@ var id: <T>(x:T) => T;
var r23 = dot(id)(id);
>r23 : <T>(_: T) => unknown
> : ^^^^ ^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^
>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
tests/baselines/reference/contextualSignatureInstantiation3.types
+4 -4
View File
@@ -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[]
> : ^ ^^ ^^ ^^^^^^^^
tests/baselines/reference/contextualSignatureInstantiationWithTypeParameterConstrainedToOuterTypeParameter.types
+1 -1
View File
@@ -35,7 +35,7 @@ var x = h("", f<string>()); // Call should succeed and x should be string. All t
>"" : ""
> : ^^
>f<string>() : <U extends string>(u: U) => U
> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^
>f : <T>() => <U extends T>(u: U) => U
> : ^ ^^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^^^^

Some files were not shown because too many files have changed in this diff Show More