From 8ccfb4a7da80485ad3f7a9a9dff11df434687957 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Fri, 31 May 2024 15:16:04 -0700 Subject: [PATCH 01/30] Analyze control flow effects of lambdas passed as arguments --- src/compiler/binder.ts | 11 +++++++++-- src/compiler/checker.ts | 37 ++++++++++++++++++++++++++++++++----- src/compiler/types.ts | 5 +++-- src/compiler/utilities.ts | 12 ++++++++++++ 4 files changed, 56 insertions(+), 9 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index ea263f471cbdc..802834e00b374 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -101,6 +101,7 @@ import { getImmediatelyInvokedFunctionExpression, getJSDocHost, getJSDocTypeTag, + getLambdaArgument, getLeftmostAccessExpression, getNameOfDeclaration, getNameOrArgument, @@ -318,6 +319,7 @@ import { unreachableCodeIsError, unusedLabelIsError, VariableDeclaration, + walkUpParenthesizedExpressions, WhileStatement, WithStatement, } from "./_namespaces/ts.js"; @@ -1015,6 +1017,8 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { !(node as FunctionLikeDeclaration).asteriskToken && !!getImmediatelyInvokedFunctionExpression(node) ) || node.kind === SyntaxKind.ClassStaticBlockDeclaration; + const isLambdaArgument = (node.kind === SyntaxKind.FunctionExpression || node.kind === SyntaxKind.ArrowFunction) && + walkUpParenthesizedExpressions(node.parent).kind === SyntaxKind.CallExpression; // A non-async, non-generator IIFE is considered part of the containing control flow. Return statements behave // similarly to break statements that exit to a label just past the statement body. if (!isImmediatelyInvoked) { @@ -1025,7 +1029,7 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { } // We create a return control flow graph for IIFEs and constructors. For constructors // we use the return control flow graph in strict property initialization checks. - currentReturnTarget = isImmediatelyInvoked || node.kind === SyntaxKind.Constructor || (isInJSFile(node) && (node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.FunctionExpression)) ? createBranchLabel() : undefined; + currentReturnTarget = isImmediatelyInvoked || isLambdaArgument || node.kind === SyntaxKind.Constructor || (isInJSFile(node) && (node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.FunctionExpression)) ? createBranchLabel() : undefined; currentExceptionTarget = undefined; currentBreakTarget = undefined; currentContinueTarget = undefined; @@ -1047,7 +1051,7 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { if (currentReturnTarget) { addAntecedent(currentReturnTarget, currentFlow); currentFlow = finishFlowLabel(currentReturnTarget); - if (node.kind === SyntaxKind.Constructor || node.kind === SyntaxKind.ClassStaticBlockDeclaration || (isInJSFile(node) && (node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.FunctionExpression))) { + if (isLambdaArgument || node.kind === SyntaxKind.Constructor || node.kind === SyntaxKind.ClassStaticBlockDeclaration || (isInJSFile(node) && (node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.FunctionExpression))) { (node as FunctionLikeDeclaration | ClassStaticBlockDeclaration).returnFlowNode = currentFlow; } } @@ -2214,6 +2218,9 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { } } } + if (some(node.arguments, arg => !!getLambdaArgument(arg))) { + currentFlow = createFlowNode(FlowFlags.LambdaArgs, node, currentFlow); + } if (node.expression.kind === SyntaxKind.PropertyAccessExpression) { const propertyAccess = node.expression as PropertyAccessExpression; if (isIdentifier(propertyAccess.name) && isNarrowableOperand(propertyAccess.expression) && isPushOrUnshiftIdentifier(propertyAccess.name)) { diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 4e7f1fe66d844..675a2d66bfebe 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1106,6 +1106,7 @@ import { WideningContext, WithStatement, YieldExpression, + getLambdaArgument, } from "./_namespaces/ts.js"; import * as moduleSpecifiers from "./_namespaces/ts.moduleSpecifiers.js"; import * as performance from "./_namespaces/ts.performance.js"; @@ -27773,8 +27774,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } noCacheCheck = false; } - if (flags & (FlowFlags.Assignment | FlowFlags.Condition | FlowFlags.ArrayMutation)) { - flow = (flow as FlowAssignment | FlowCondition | FlowArrayMutation).antecedent; + if (flags & (FlowFlags.Assignment | FlowFlags.Condition | FlowFlags.ArrayMutation | FlowFlags.LambdaArgs)) { + flow = (flow as FlowAssignment | FlowCondition | FlowArrayMutation | FlowCall).antecedent; } else if (flags & FlowFlags.Call) { const signature = getEffectsSignature((flow as FlowCall).node); @@ -27842,8 +27843,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } noCacheCheck = false; } - if (flags & (FlowFlags.Assignment | FlowFlags.Condition | FlowFlags.ArrayMutation | FlowFlags.SwitchClause)) { - flow = (flow as FlowAssignment | FlowCondition | FlowArrayMutation | FlowSwitchClause).antecedent; + if (flags & (FlowFlags.Assignment | FlowFlags.Condition | FlowFlags.ArrayMutation | FlowFlags.SwitchClause | FlowFlags.LambdaArgs)) { + flow = (flow as FlowAssignment | FlowCondition | FlowArrayMutation | FlowSwitchClause | FlowCall).antecedent; } else if (flags & FlowFlags.Call) { if ((flow as FlowCall).node.expression.kind === SyntaxKind.SuperKeyword) { @@ -27903,6 +27904,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { function getFlowTypeOfReference(reference: Node, declaredType: Type, initialType = declaredType, flowContainer?: Node, flowNode = tryCast(reference, canHaveFlowNode)?.flowNode) { let key: string | undefined; let isKeySet = false; + let inLambdaArg = false; let flowDepth = 0; if (flowAnalysisDisabled) { return errorType; @@ -27994,6 +27996,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { continue; } } + else if (flags & FlowFlags.LambdaArgs) { + type = getTypeAtFlowLambdaArgs(flow as FlowCall); + } else if (flags & FlowFlags.ReduceLabel) { const target = (flow as FlowReduceLabel).node.target; const saveAntecedents = target.antecedent; @@ -28005,7 +28010,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // Check if we should continue with the control flow of the containing function. const container = (flow as FlowStart).node; if ( - container && container !== flowContainer && + container && container !== flowContainer && !inLambdaArg && reference.kind !== SyntaxKind.PropertyAccessExpression && reference.kind !== SyntaxKind.ElementAccessExpression && !(reference.kind === SyntaxKind.ThisKeyword && container.kind !== SyntaxKind.ArrowFunction) @@ -28132,6 +28137,28 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return undefined; } + function getTypeAtFlowLambdaArgs(flow: FlowCall): FlowType { + const flowType = getTypeAtFlowNode(flow.antecedent); + const saveInitialType = initialType; + const saveInLambdaArg = inLambdaArg; + initialType = getTypeFromFlowType(flowType); + inLambdaArg = true; + let lambdaTypes: Type[] | undefined; + for (const arg of flow.node.arguments) { + const lambda = getLambdaArgument(arg); + if (lambda && lambda.returnFlowNode) { + const lambdaType = getTypeFromFlowType(getTypeAtFlowNode(lambda.returnFlowNode)); + if (lambdaType !== initialType) { + lambdaTypes ??= [initialType]; + lambdaTypes.push(lambdaType); + } + } + } + inLambdaArg = saveInLambdaArg; + initialType = saveInitialType; + return lambdaTypes ? createFlowType(getUnionOrEvolvingArrayType(lambdaTypes, UnionReduction.Literal), isIncomplete(flowType)) : flowType; + } + function getTypeAtFlowArrayMutation(flow: FlowArrayMutation): FlowType | undefined { if (declaredType === autoType || declaredType === autoArrayType) { const node = flow.node; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 7c557eff1d6fc..1ef24049ee89e 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -4111,8 +4111,9 @@ export const enum FlowFlags { ArrayMutation = 1 << 8, // Potential array mutation Call = 1 << 9, // Potential assertion call ReduceLabel = 1 << 10, // Temporarily reduce antecedents of label - Referenced = 1 << 11, // Referenced as antecedent once - Shared = 1 << 12, // Referenced as antecedent more than once + LambdaArgs = 1 << 11, // Call expression with lambda arguments + Referenced = 1 << 12, // Referenced as antecedent once + Shared = 1 << 13, // Referenced as antecedent more than once Label = BranchLabel | LoopLabel, Condition = TrueCondition | FalseCondition, diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 4cf5f0082cd20..17c32d5261963 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -11632,3 +11632,15 @@ export function hasInferredType(node: Node): node is HasInferredType { return false; } } + +/** @internal */ +export function getLambdaArgument(node: Node): FunctionLikeDeclaration | undefined { + switch (node.kind) { + case SyntaxKind.FunctionExpression: + case SyntaxKind.ArrowFunction: + return node as FunctionLikeDeclaration; + case SyntaxKind.ParenthesizedExpression: + return getLambdaArgument((node as ParenthesizedExpression).expression); + } + return undefined; +} From e4d20f86684b0f3f289f2762b5e0bfc39cc5d96b Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Fri, 31 May 2024 15:16:19 -0700 Subject: [PATCH 02/30] Accept new baselines --- tests/baselines/reference/parserharness.types | 4 ++-- tests/baselines/reference/parserindenter.types | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/baselines/reference/parserharness.types b/tests/baselines/reference/parserharness.types index da5fe14851731..754d37ca0c2be 100644 --- a/tests/baselines/reference/parserharness.types +++ b/tests/baselines/reference/parserharness.types @@ -1838,8 +1838,8 @@ module Harness { }); return isAsync; ->isAsync : true -> : ^^^^ +>isAsync : boolean +> : ^^^^^^^ } } catch (e) { diff --git a/tests/baselines/reference/parserindenter.types b/tests/baselines/reference/parserindenter.types index 0d93f460d18e4..02d35ccb26511 100644 --- a/tests/baselines/reference/parserindenter.types +++ b/tests/baselines/reference/parserindenter.types @@ -2328,8 +2328,8 @@ module Formatting { }); return result; ->result : true -> : ^^^^ +>result : boolean +> : ^^^^^^^ } return false; From de9171e711b54eb29204d7cf50d855f875005b63 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 3 Jun 2024 15:41:26 -0700 Subject: [PATCH 03/30] Formatting + handle unreachable code --- src/compiler/checker.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 675a2d66bfebe..ac7e4126b8464 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -328,6 +328,7 @@ import { getJSXImplicitImportBase, getJSXRuntimeImport, getJSXTransformEnabled, + getLambdaArgument, getLeftmostAccessExpression, getLineAndCharacterOfPosition, getMembersOfDeclaration, @@ -1106,7 +1107,6 @@ import { WideningContext, WithStatement, YieldExpression, - getLambdaArgument, } from "./_namespaces/ts.js"; import * as moduleSpecifiers from "./_namespaces/ts.moduleSpecifiers.js"; import * as performance from "./_namespaces/ts.performance.js"; @@ -28024,7 +28024,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { else { // Unreachable code errors are reported in the binding phase. Here we // simply return the non-auto declared type to reduce follow-on errors. - type = convertAutoToAny(declaredType); + type = inLambdaArg ? initialType : convertAutoToAny(declaredType); } if (sharedFlow) { // Record visited node and the associated type in the cache. From 18f1ba9d627934e2112df22fb949a05a3e093f55 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 5 Jun 2024 15:31:23 -0700 Subject: [PATCH 04/30] Add Deferred intrinsic + only check lambdas with mutation flow nodes --- src/compiler/binder.ts | 36 +++++++++++++++++++-------- src/compiler/checker.ts | 35 +++++++++++++++++++++++--- src/compiler/types.ts | 3 ++- src/compiler/utilities.ts | 2 +- src/harness/fourslashInterfaceImpl.ts | 1 + src/lib/es5.d.ts | 5 ++++ 6 files changed, 65 insertions(+), 17 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 802834e00b374..0b5f5a8f15b29 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -546,6 +546,7 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { var activeLabelList: ActiveLabel | undefined; var hasExplicitReturn: boolean; var hasFlowEffects: boolean; + var hasFlowMutation: boolean; // state used for emit helpers var emitFlags: NodeFlags; @@ -625,6 +626,7 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { activeLabelList = undefined; hasExplicitReturn = false; hasFlowEffects = false; + hasFlowMutation = false; inAssignmentPattern = false; emitFlags = NodeFlags.None; } @@ -1011,14 +1013,11 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { const saveExceptionTarget = currentExceptionTarget; const saveActiveLabelList = activeLabelList; const saveHasExplicitReturn = hasExplicitReturn; - const isImmediatelyInvoked = ( - containerFlags & ContainerFlags.IsFunctionExpression && + const isRegularFunctionExpression = containerFlags & ContainerFlags.IsFunctionExpression && !hasSyntacticModifier(node, ModifierFlags.Async) && - !(node as FunctionLikeDeclaration).asteriskToken && - !!getImmediatelyInvokedFunctionExpression(node) - ) || node.kind === SyntaxKind.ClassStaticBlockDeclaration; - const isLambdaArgument = (node.kind === SyntaxKind.FunctionExpression || node.kind === SyntaxKind.ArrowFunction) && - walkUpParenthesizedExpressions(node.parent).kind === SyntaxKind.CallExpression; + !(node as FunctionLikeDeclaration).asteriskToken; + const isImmediatelyInvoked = isRegularFunctionExpression && !!getImmediatelyInvokedFunctionExpression(node) || node.kind === SyntaxKind.ClassStaticBlockDeclaration; + const isLambdaArgument = isRegularFunctionExpression && walkUpParenthesizedExpressions(node.parent).kind === SyntaxKind.CallExpression; // A non-async, non-generator IIFE is considered part of the containing control flow. Return statements behave // similarly to break statements that exit to a label just past the statement body. if (!isImmediatelyInvoked) { @@ -1394,6 +1393,7 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { function createFlowMutation(flags: FlowFlags.Assignment | FlowFlags.ArrayMutation, antecedent: FlowNode, node: Expression | VariableDeclaration | ArrayBindingElement) { setFlowNodeReferenced(antecedent); hasFlowEffects = true; + hasFlowMutation = true; const result = createFlowNode(flags, node, antecedent) as FlowAssignment | FlowArrayMutation; if (currentExceptionTarget) { addAntecedent(currentExceptionTarget, result); @@ -1407,6 +1407,11 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { return createFlowNode(FlowFlags.Call, node, antecedent) as FlowCall; } + function createFlowLambdaArgs(antecedent: FlowNode, node: CallExpression) { + setFlowNodeReferenced(antecedent); + return createFlowNode(FlowFlags.LambdaArgs, node, antecedent) as FlowCall; + } + function finishFlowLabel(flow: FlowLabel): FlowNode { const antecedents = flow.antecedent; if (!antecedents) { @@ -2212,15 +2217,24 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { bind(node.expression); } else { - bindEachChild(node); + bind(node.expression); + bindEach(node.typeArguments); + let hasLambdaArgs = false; + for (const arg of node.arguments) { + const saveHasFlowMutation = hasFlowMutation; + hasFlowMutation = false; + bind(arg); + hasLambdaArgs ||= !!getLambdaArgument(arg) && hasFlowMutation; + hasFlowMutation ||= saveHasFlowMutation; + } if (node.expression.kind === SyntaxKind.SuperKeyword) { currentFlow = createFlowCall(currentFlow, node); } + if (hasLambdaArgs) { + currentFlow = createFlowLambdaArgs(currentFlow, node); + } } } - if (some(node.arguments, arg => !!getLambdaArgument(arg))) { - currentFlow = createFlowNode(FlowFlags.LambdaArgs, node, currentFlow); - } if (node.expression.kind === SyntaxKind.PropertyAccessExpression) { const propertyAccess = node.expression as PropertyAccessExpression; if (isIdentifier(propertyAccess.name) && isNarrowableOperand(propertyAccess.expression) && isPushOrUnshiftIdentifier(propertyAccess.name)) { diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index ac7e4126b8464..50139d931fee8 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1396,6 +1396,7 @@ const enum IntrinsicTypeKind { Capitalize, Uncapitalize, NoInfer, + Deferred, } const intrinsicTypeKinds: ReadonlyMap = new Map(Object.entries({ @@ -1404,6 +1405,7 @@ const intrinsicTypeKinds: ReadonlyMap = new Map(Objec Capitalize: IntrinsicTypeKind.Capitalize, Uncapitalize: IntrinsicTypeKind.Uncapitalize, NoInfer: IntrinsicTypeKind.NoInfer, + Deferred: IntrinsicTypeKind.Deferred, })); const SymbolLinks = class implements SymbolLinks { @@ -16100,7 +16102,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (type === intrinsicMarkerType) { const typeKind = intrinsicTypeKinds.get(symbol.escapedName as string); if (typeKind !== undefined && typeArguments && typeArguments.length === 1) { - return typeKind === IntrinsicTypeKind.NoInfer ? getNoInferType(typeArguments[0]) : getStringMappingType(symbol, typeArguments[0]); + return typeKind === IntrinsicTypeKind.NoInfer ? getNoInferType(typeArguments[0]) : + typeKind === IntrinsicTypeKind.Deferred ? getDeferredCallbackType(typeArguments[0], aliasSymbol, aliasTypeArguments) : + getStringMappingType(symbol, typeArguments[0]); } } const links = getSymbolLinks(symbol); @@ -16113,6 +16117,27 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return instantiation; } + function getDeferredCallbackType(type: Type, aliasSymbol: Symbol | undefined, aliasTypeArguments: readonly Type[] | undefined) { + if (type.flags & TypeFlags.Object) { + const key = `F${getTypeId(type)}${getAliasId(aliasSymbol, aliasTypeArguments)}`; + return getCachedType(key) ?? setCachedType(key, createDeferredCallbackType(type as ObjectType, aliasSymbol, aliasTypeArguments)); + } + return type; + } + + function createDeferredCallbackType(type: ObjectType, aliasSymbol: Symbol | undefined, aliasTypeArguments: readonly Type[] | undefined) { + const resolved = resolveStructuredTypeMembers(type); + const result = createObjectType(ObjectFlags.Anonymous | ObjectFlags.DeferredCallback, type.symbol); + result.members = resolved.members; + result.properties = resolved.properties; + result.callSignatures = resolved.callSignatures; + result.constructSignatures = resolved.constructSignatures; + result.indexInfos = resolved.indexInfos; + result.aliasSymbol = aliasSymbol; + result.aliasTypeArguments = aliasTypeArguments; + return result; + } + /** * Get type from reference to type alias. When a type alias is generic, the declared type of the type alias may include * references to the type parameters of the alias. We replace those with the actual type arguments by instantiating the @@ -28138,15 +28163,17 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function getTypeAtFlowLambdaArgs(flow: FlowCall): FlowType { + const signature = getResolvedSignature(flow.node); const flowType = getTypeAtFlowNode(flow.antecedent); const saveInitialType = initialType; const saveInLambdaArg = inLambdaArg; initialType = getTypeFromFlowType(flowType); inLambdaArg = true; let lambdaTypes: Type[] | undefined; - for (const arg of flow.node.arguments) { - const lambda = getLambdaArgument(arg); - if (lambda && lambda.returnFlowNode) { + const args = flow.node.arguments; + for (let i = 0; i < args.length; i++) { + const lambda = getLambdaArgument(args[i]); + if (lambda && lambda.returnFlowNode && !(getObjectFlags(getTypeAtPosition(signature, i)) & ObjectFlags.DeferredCallback)) { const lambdaType = getTypeFromFlowType(getTypeAtFlowNode(lambda.returnFlowNode)); if (lambdaType !== initialType) { lambdaTypes ??= [initialType]; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 1ef24049ee89e..6f69adc86759c 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -6381,7 +6381,6 @@ export const enum ObjectFlags { ContainsSpread = 1 << 21, // Object literal contains spread operation ObjectRestType = 1 << 22, // Originates in object rest declaration InstantiationExpressionType = 1 << 23, // Originates in instantiation expression - SingleSignatureType = 1 << 27, // A single signature type extracted from a potentially broader type /** @internal */ IsClassInstanceClone = 1 << 24, // Type is a clone of a class instance type // Flags that require TypeFlags.Object and ObjectFlags.Reference @@ -6389,6 +6388,8 @@ export const enum ObjectFlags { IdenticalBaseTypeCalculated = 1 << 25, // has had `getSingleBaseForNonAugmentingSubtype` invoked on it already /** @internal */ IdenticalBaseTypeExists = 1 << 26, // has a defined cachedEquivalentBaseType member + SingleSignatureType = 1 << 27, // A single signature type extracted from a potentially broader type + DeferredCallback = 1 << 28, // Function type with Deferred marker // Flags that require TypeFlags.UnionOrIntersection or TypeFlags.Substitution /** @internal */ diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 17c32d5261963..918a7974c0c7e 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -11638,7 +11638,7 @@ export function getLambdaArgument(node: Node): FunctionLikeDeclaration | undefin switch (node.kind) { case SyntaxKind.FunctionExpression: case SyntaxKind.ArrowFunction: - return node as FunctionLikeDeclaration; + return !hasSyntacticModifier(node, ModifierFlags.Async) && !(node as FunctionLikeDeclaration).asteriskToken ? node as FunctionLikeDeclaration : undefined; case SyntaxKind.ParenthesizedExpression: return getLambdaArgument((node as ParenthesizedExpression).expression); } diff --git a/src/harness/fourslashInterfaceImpl.ts b/src/harness/fourslashInterfaceImpl.ts index f04ac4594f918..7400966d833ab 100644 --- a/src/harness/fourslashInterfaceImpl.ts +++ b/src/harness/fourslashInterfaceImpl.ts @@ -1210,6 +1210,7 @@ export namespace Completion { typeEntry("Capitalize"), typeEntry("Uncapitalize"), typeEntry("NoInfer"), + typeEntry("Deferred"), interfaceEntry("ThisType"), varEntry("ArrayBuffer"), interfaceEntry("ArrayBufferTypes"), diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index 33bbb99147490..3fc2031efd146 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -1654,6 +1654,11 @@ type Uncapitalize = intrinsic; */ type NoInfer = intrinsic; +/** + * Marker for deferred callbacks + */ +type Deferred any> = intrinsic; + /** * Marker for contextual 'this' type */ From 46f6706dda7a0bf18344c56253da5ee20f217014 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 5 Jun 2024 15:31:47 -0700 Subject: [PATCH 05/30] Accept new baselines --- tests/baselines/reference/api/typescript.d.ts | 1 + .../autoImportProvider_namespaceSameNameAsIntrinsic.js | 6 ++++++ .../fourslashServer/pasteEdits_revertUpdatedFile.js | 6 ++++++ 3 files changed, 13 insertions(+) diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index e6dfbf9200437..414cb8a6bdf3e 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -6647,6 +6647,7 @@ declare namespace ts { ObjectRestType = 4194304, InstantiationExpressionType = 8388608, SingleSignatureType = 134217728, + DeferredCallback = 268435456, } interface ObjectType extends Type { objectFlags: ObjectFlags; diff --git a/tests/baselines/reference/tsserver/fourslashServer/autoImportProvider_namespaceSameNameAsIntrinsic.js b/tests/baselines/reference/tsserver/fourslashServer/autoImportProvider_namespaceSameNameAsIntrinsic.js index ffb5faecf4d5f..ac7c72244be5c 100644 --- a/tests/baselines/reference/tsserver/fourslashServer/autoImportProvider_namespaceSameNameAsIntrinsic.js +++ b/tests/baselines/reference/tsserver/fourslashServer/autoImportProvider_namespaceSameNameAsIntrinsic.js @@ -584,6 +584,12 @@ Info seq [hh:mm:ss:mss] response: "kindModifiers": "declare", "sortText": "15" }, + { + "name": "Deferred", + "kind": "type", + "kindModifiers": "declare", + "sortText": "15" + }, { "name": "Error", "kind": "var", diff --git a/tests/baselines/reference/tsserver/fourslashServer/pasteEdits_revertUpdatedFile.js b/tests/baselines/reference/tsserver/fourslashServer/pasteEdits_revertUpdatedFile.js index 3386cebb96943..0b4906ca49baa 100644 --- a/tests/baselines/reference/tsserver/fourslashServer/pasteEdits_revertUpdatedFile.js +++ b/tests/baselines/reference/tsserver/fourslashServer/pasteEdits_revertUpdatedFile.js @@ -607,6 +607,12 @@ Info seq [hh:mm:ss:mss] response: "kindModifiers": "declare", "sortText": "15" }, + { + "name": "Deferred", + "kind": "type", + "kindModifiers": "declare", + "sortText": "15" + }, { "name": "Error", "kind": "var", From dd597102a4e8d308864fd886b41be47761a799fb Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Wed, 5 Jun 2024 15:43:11 -0700 Subject: [PATCH 06/30] Local declarations don't mutate captured outer variables --- src/compiler/binder.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 0b5f5a8f15b29..0a9fcdbb464c9 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -1393,7 +1393,7 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { function createFlowMutation(flags: FlowFlags.Assignment | FlowFlags.ArrayMutation, antecedent: FlowNode, node: Expression | VariableDeclaration | ArrayBindingElement) { setFlowNodeReferenced(antecedent); hasFlowEffects = true; - hasFlowMutation = true; + if (node.kind !== SyntaxKind.VariableDeclaration && node.kind !== SyntaxKind.BindingElement) hasFlowMutation = true; const result = createFlowNode(flags, node, antecedent) as FlowAssignment | FlowArrayMutation; if (currentExceptionTarget) { addAntecedent(currentExceptionTarget, result); From 63ef24968084f1c8b48642f15111f9cdfcc5900e Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 6 Jun 2024 05:56:36 -0700 Subject: [PATCH 07/30] Less aggressive call resolution --- src/compiler/checker.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 50139d931fee8..844a6f63a311a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -28163,7 +28163,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function getTypeAtFlowLambdaArgs(flow: FlowCall): FlowType { - const signature = getResolvedSignature(flow.node); + const signatures = getSignaturesOfType(getTypeOfExpression(flow.node.expression), SignatureKind.Call); const flowType = getTypeAtFlowNode(flow.antecedent); const saveInitialType = initialType; const saveInLambdaArg = inLambdaArg; @@ -28173,7 +28173,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const args = flow.node.arguments; for (let i = 0; i < args.length; i++) { const lambda = getLambdaArgument(args[i]); - if (lambda && lambda.returnFlowNode && !(getObjectFlags(getTypeAtPosition(signature, i)) & ObjectFlags.DeferredCallback)) { + if (lambda && lambda.returnFlowNode && !some(signatures, sig => !!(getObjectFlags(getTypeAtPosition(sig, i)) & ObjectFlags.DeferredCallback))) { const lambdaType = getTypeFromFlowType(getTypeAtFlowNode(lambda.returnFlowNode)); if (lambdaType !== initialType) { lambdaTypes ??= [initialType]; From 0523c63c6c8dc01b18f83d832aedebfe2352dcbd Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Fri, 7 Jun 2024 13:55:23 -0700 Subject: [PATCH 08/30] Optimize lambda assignment analysis using isMutableFlowNode walk --- src/compiler/binder.ts | 2 +- src/compiler/checker.ts | 70 +++++++++++++++++++++++++++++++++++++---- 2 files changed, 65 insertions(+), 7 deletions(-) diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 0a9fcdbb464c9..4a033cef52d89 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -1050,7 +1050,7 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { if (currentReturnTarget) { addAntecedent(currentReturnTarget, currentFlow); currentFlow = finishFlowLabel(currentReturnTarget); - if (isLambdaArgument || node.kind === SyntaxKind.Constructor || node.kind === SyntaxKind.ClassStaticBlockDeclaration || (isInJSFile(node) && (node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.FunctionExpression))) { + if (isLambdaArgument && hasFlowMutation || node.kind === SyntaxKind.Constructor || node.kind === SyntaxKind.ClassStaticBlockDeclaration || (isInJSFile(node) && (node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.FunctionExpression))) { (node as FunctionLikeDeclaration | ClassStaticBlockDeclaration).returnFlowNode = currentFlow; } } diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 844a6f63a311a..389a6c7783526 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -27928,6 +27928,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { function getFlowTypeOfReference(reference: Node, declaredType: Type, initialType = declaredType, flowContainer?: Node, flowNode = tryCast(reference, canHaveFlowNode)?.flowNode) { let key: string | undefined; + let hasMutation: boolean[] | undefined; let isKeySet = false; let inLambdaArg = false; let flowDepth = 0; @@ -28163,21 +28164,24 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function getTypeAtFlowLambdaArgs(flow: FlowCall): FlowType { - const signatures = getSignaturesOfType(getTypeOfExpression(flow.node.expression), SignatureKind.Call); const flowType = getTypeAtFlowNode(flow.antecedent); const saveInitialType = initialType; const saveInLambdaArg = inLambdaArg; initialType = getTypeFromFlowType(flowType); inLambdaArg = true; let lambdaTypes: Type[] | undefined; + let signatures: readonly Signature[] | undefined; const args = flow.node.arguments; for (let i = 0; i < args.length; i++) { const lambda = getLambdaArgument(args[i]); - if (lambda && lambda.returnFlowNode && !some(signatures, sig => !!(getObjectFlags(getTypeAtPosition(sig, i)) & ObjectFlags.DeferredCallback))) { - const lambdaType = getTypeFromFlowType(getTypeAtFlowNode(lambda.returnFlowNode)); - if (lambdaType !== initialType) { - lambdaTypes ??= [initialType]; - lambdaTypes.push(lambdaType); + if (lambda && lambda.returnFlowNode && isMutationFlowNode(lambda.returnFlowNode, /*noCacheCheck*/ false)) { + signatures ??= getSignaturesOfType(getTypeOfExpression(flow.node.expression), SignatureKind.Call); + if (!some(signatures, sig => !!(getObjectFlags(getTypeAtPosition(sig, i)) & ObjectFlags.DeferredCallback))) { + const lambdaType = getTypeFromFlowType(getTypeAtFlowNode(lambda.returnFlowNode)); + if (lambdaType !== initialType) { + lambdaTypes ??= [initialType]; + lambdaTypes.push(lambdaType); + } } } } @@ -28186,6 +28190,60 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return lambdaTypes ? createFlowType(getUnionOrEvolvingArrayType(lambdaTypes, UnionReduction.Literal), isIncomplete(flowType)) : flowType; } + function isMutationFlowNode(flow: FlowNode, noCacheCheck: boolean): boolean { + while (true) { + const flags = flow.flags; + if (flags & FlowFlags.Shared) { + if (!noCacheCheck) { + const id = getFlowNodeId(flow); + const cached = (hasMutation ??= [])[id]; + return cached !== undefined ? cached : (hasMutation[id] = isMutationFlowNode(flow, /*noCacheCheck*/ true)); + } + noCacheCheck = false; + } + if (flags & (FlowFlags.Call | FlowFlags.Condition | FlowFlags.SwitchClause | FlowFlags.ReduceLabel)) { + flow = (flow as FlowCall | FlowCondition | FlowSwitchClause | FlowReduceLabel).antecedent; + } + else if (flags & FlowFlags.Assignment) { + if (isOrContainsMatchingReference(reference, (flow as FlowArrayMutation).node)) { + return true; + } + flow = (flow as FlowAssignment).antecedent; + } + else if (flags & FlowFlags.BranchLabel) { + return some((flow as FlowLabel).antecedent, f => isMutationFlowNode(f, /*noCacheCheck*/ false)); + } + else if (flags & FlowFlags.LoopLabel) { + const id = getFlowNodeId(flow); + const cached = (hasMutation ??= [])[id]; + if (cached !== undefined) return cached; + hasMutation[id] = false; + return hasMutation[id] = some((flow as FlowLabel).antecedent, f => isMutationFlowNode(f, /*noCacheCheck*/ false)); + } + else if (flags & FlowFlags.ArrayMutation) { + if (declaredType === autoType || declaredType === autoArrayType) { + const node = (flow as FlowArrayMutation).node; + const expr = node.kind === SyntaxKind.CallExpression ? + (node.expression as PropertyAccessExpression).expression : + (node.left as ElementAccessExpression).expression; + if (isMatchingReference(reference, getReferenceCandidate(expr))) { + return true; + } + } + flow = (flow as FlowArrayMutation).antecedent; + } + else if (flags & FlowFlags.LambdaArgs) { + return some((flow as FlowCall).node.arguments, arg => { + const lambda = getLambdaArgument(arg); + return !!(lambda && lambda.returnFlowNode && isMutationFlowNode(lambda.returnFlowNode, /*noCacheCheck*/ false)); + }); + } + else { + return false; + } + } + } + function getTypeAtFlowArrayMutation(flow: FlowArrayMutation): FlowType | undefined { if (declaredType === autoType || declaredType === autoArrayType) { const node = flow.node; From 3dbb4f49a283836c4d1f471f70c978e7fd7d4ede Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Sat, 8 Jun 2024 06:47:33 -0700 Subject: [PATCH 09/30] Allocation-free caching in isMutationFlowNode --- src/compiler/checker.ts | 57 +++++++++++++++++++++++++++++------------ 1 file changed, 40 insertions(+), 17 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 389a6c7783526..767f826ecdbb0 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -2265,6 +2265,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { var flowLoopStart = 0; var flowLoopCount = 0; var sharedFlowCount = 0; + var mutationFlowCount = 0; var flowAnalysisDisabled = false; var flowInvocationCount = 0; var lastFlowNode: FlowNode | undefined; @@ -2301,6 +2302,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { var flowLoopTypes: Type[][] = []; var sharedFlowNodes: FlowNode[] = []; var sharedFlowTypes: FlowType[] = []; + var mutationFlowNodes: FlowNode[] = []; + var mutationFlowStates: boolean[] = []; var flowNodeReachable: (boolean | undefined)[] = []; var flowNodePostSuper: (boolean | undefined)[] = []; var potentialThisCollisions: Node[] = []; @@ -27928,7 +27931,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { function getFlowTypeOfReference(reference: Node, declaredType: Type, initialType = declaredType, flowContainer?: Node, flowNode = tryCast(reference, canHaveFlowNode)?.flowNode) { let key: string | undefined; - let hasMutation: boolean[] | undefined; let isKeySet = false; let inLambdaArg = false; let flowDepth = 0; @@ -27940,8 +27942,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } flowInvocationCount++; const sharedFlowStart = sharedFlowCount; + const mutationFlowStart = mutationFlowCount; const evolvedType = getTypeFromFlowType(getTypeAtFlowNode(flowNode)); sharedFlowCount = sharedFlowStart; + mutationFlowCount = mutationFlowStart; // When the reference is 'x' in an 'x.length', 'x.push(value)', 'x.unshift(value)' or x[n] = value' operation, // we give type 'any[]' to 'x' instead of using the type determined by control flow analysis such that operations // on empty arrays are possible without implicit any errors and new element types can be inferred without @@ -28195,30 +28199,29 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const flags = flow.flags; if (flags & FlowFlags.Shared) { if (!noCacheCheck) { - const id = getFlowNodeId(flow); - const cached = (hasMutation ??= [])[id]; - return cached !== undefined ? cached : (hasMutation[id] = isMutationFlowNode(flow, /*noCacheCheck*/ true)); + let cached = getMutationStateForFlowNode(flow); + if (cached === undefined) { + setMutationStateForFlowNode(flow, cached = isMutationFlowNode(flow, /*noCacheCheck*/ true)); + } + return cached; } noCacheCheck = false; } - if (flags & (FlowFlags.Call | FlowFlags.Condition | FlowFlags.SwitchClause | FlowFlags.ReduceLabel)) { - flow = (flow as FlowCall | FlowCondition | FlowSwitchClause | FlowReduceLabel).antecedent; - } - else if (flags & FlowFlags.Assignment) { + if (flags & FlowFlags.Assignment) { if (isOrContainsMatchingReference(reference, (flow as FlowArrayMutation).node)) { return true; } - flow = (flow as FlowAssignment).antecedent; } else if (flags & FlowFlags.BranchLabel) { return some((flow as FlowLabel).antecedent, f => isMutationFlowNode(f, /*noCacheCheck*/ false)); } else if (flags & FlowFlags.LoopLabel) { - const id = getFlowNodeId(flow); - const cached = (hasMutation ??= [])[id]; - if (cached !== undefined) return cached; - hasMutation[id] = false; - return hasMutation[id] = some((flow as FlowLabel).antecedent, f => isMutationFlowNode(f, /*noCacheCheck*/ false)); + let cached = getMutationStateForFlowNode(flow); + if (cached === undefined) { + const index = setMutationStateForFlowNode(flow, false); + cached = mutationFlowStates[index] = some((flow as FlowLabel).antecedent, f => isMutationFlowNode(f, /*noCacheCheck*/ false)); + } + return cached; } else if (flags & FlowFlags.ArrayMutation) { if (declaredType === autoType || declaredType === autoArrayType) { @@ -28230,18 +28233,38 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return true; } } - flow = (flow as FlowArrayMutation).antecedent; } else if (flags & FlowFlags.LambdaArgs) { - return some((flow as FlowCall).node.arguments, arg => { + const mutation = some((flow as FlowCall).node.arguments, arg => { const lambda = getLambdaArgument(arg); return !!(lambda && lambda.returnFlowNode && isMutationFlowNode(lambda.returnFlowNode, /*noCacheCheck*/ false)); }); + if (mutation) { + return true; + } } - else { + else if (!(flags & (FlowFlags.Call | FlowFlags.Condition | FlowFlags.SwitchClause | FlowFlags.ReduceLabel))) { return false; } + flow = (flow as FlowAssignment | FlowArrayMutation | FlowCall | FlowCondition | FlowSwitchClause | FlowReduceLabel).antecedent; + } + } + + function getMutationStateForFlowNode(flow: FlowNode) { + for (let i = mutationFlowStart; i < mutationFlowCount; i++) { + if (mutationFlowNodes[i] === flow) { + return mutationFlowStates[i]; + } } + return undefined; + } + + function setMutationStateForFlowNode(flow: FlowNode, state: boolean) { + const index = mutationFlowCount; + mutationFlowNodes[index] = flow; + mutationFlowStates[index] = state; + mutationFlowCount++; + return index; } function getTypeAtFlowArrayMutation(flow: FlowArrayMutation): FlowType | undefined { From 738f6b5087a557551113691c70bbedf9e3e01e4b Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 10 Jun 2024 10:28:32 -0700 Subject: [PATCH 10/30] Only analyze lambdas when widening is possible --- src/compiler/checker.ts | 41 ++++++++++++++++++++++++++--------------- 1 file changed, 26 insertions(+), 15 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 767f826ecdbb0..0a2a2deb6cf59 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -28170,26 +28170,37 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { function getTypeAtFlowLambdaArgs(flow: FlowCall): FlowType { const flowType = getTypeAtFlowNode(flow.antecedent); const saveInitialType = initialType; - const saveInLambdaArg = inLambdaArg; initialType = getTypeFromFlowType(flowType); - inLambdaArg = true; let lambdaTypes: Type[] | undefined; - let signatures: readonly Signature[] | undefined; - const args = flow.node.arguments; - for (let i = 0; i < args.length; i++) { - const lambda = getLambdaArgument(args[i]); - if (lambda && lambda.returnFlowNode && isMutationFlowNode(lambda.returnFlowNode, /*noCacheCheck*/ false)) { - signatures ??= getSignaturesOfType(getTypeOfExpression(flow.node.expression), SignatureKind.Call); - if (!some(signatures, sig => !!(getObjectFlags(getTypeAtPosition(sig, i)) & ObjectFlags.DeferredCallback))) { - const lambdaType = getTypeFromFlowType(getTypeAtFlowNode(lambda.returnFlowNode)); - if (lambdaType !== initialType) { - lambdaTypes ??= [initialType]; - lambdaTypes.push(lambdaType); + // We assume that lambda arguments may or may not have executed. Thus, lambda arguments can only have a widening + // effect and will have no effect if we already have the declared type (the widest possible type). + if (initialType !== declaredType) { + const saveInLambdaArg = inLambdaArg; + inLambdaArg = true; + const args = flow.node.arguments; + let signatures: readonly Signature[] | undefined; + for (let i = 0; i < args.length; i++) { + const lambda = getLambdaArgument(args[i]); + // We use isMutationFlowNode to quickly check whether the reference is mutated anywhere in the lambda. + // This check doesn't require resolving any types, thus eliminating circularities that would otherwise + // occur for no good reason. + if (lambda && lambda.returnFlowNode && isMutationFlowNode(lambda.returnFlowNode, /*noCacheCheck*/ false)) { + // Only when we know that the reference is actually mutated in the lambda do we resolve types and + // signatures. Note that we don't perform type inference and overload resolution, again to reduce + // circularities. Instead, we simply check if any signature has a deferred callback marker in the + // particular argument position. + signatures ??= getSignaturesOfType(getTypeOfExpression(flow.node.expression), SignatureKind.Call); + if (!some(signatures, sig => !!(getObjectFlags(getTypeAtPosition(sig, i)) & ObjectFlags.DeferredCallback))) { + const lambdaType = getTypeFromFlowType(getTypeAtFlowNode(lambda.returnFlowNode)); + if (lambdaType !== initialType) { + lambdaTypes ??= [initialType]; + lambdaTypes.push(lambdaType); + } } } } + inLambdaArg = saveInLambdaArg; } - inLambdaArg = saveInLambdaArg; initialType = saveInitialType; return lambdaTypes ? createFlowType(getUnionOrEvolvingArrayType(lambdaTypes, UnionReduction.Literal), isIncomplete(flowType)) : flowType; } @@ -28208,7 +28219,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { noCacheCheck = false; } if (flags & FlowFlags.Assignment) { - if (isOrContainsMatchingReference(reference, (flow as FlowArrayMutation).node)) { + if (isOrContainsMatchingReference(reference, (flow as FlowAssignment).node)) { return true; } } From 3ae7cb22dc6da7d3a5762c1d1aabe14e71ef72c4 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 13 Jun 2024 07:14:09 -0700 Subject: [PATCH 11/30] Implement 'deferred' modifier, remove Deferred marker type --- src/compiler/checker.ts | 50 ++++++++++++--------------- src/compiler/diagnosticMessages.json | 8 +++++ src/compiler/factory/nodeFactory.ts | 2 ++ src/compiler/program.ts | 1 + src/compiler/scanner.ts | 1 + src/compiler/transformers/ts.ts | 1 + src/compiler/types.ts | 17 +++++---- src/compiler/utilities.ts | 2 ++ src/compiler/utilitiesPublic.ts | 1 + src/harness/fourslashInterfaceImpl.ts | 1 - src/lib/es5.d.ts | 5 --- 11 files changed, 50 insertions(+), 39 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 0a2a2deb6cf59..a7a0727e7d8ea 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -1396,7 +1396,6 @@ const enum IntrinsicTypeKind { Capitalize, Uncapitalize, NoInfer, - Deferred, } const intrinsicTypeKinds: ReadonlyMap = new Map(Object.entries({ @@ -1405,7 +1404,6 @@ const intrinsicTypeKinds: ReadonlyMap = new Map(Objec Capitalize: IntrinsicTypeKind.Capitalize, Uncapitalize: IntrinsicTypeKind.Uncapitalize, NoInfer: IntrinsicTypeKind.NoInfer, - Deferred: IntrinsicTypeKind.Deferred, })); const SymbolLinks = class implements SymbolLinks { @@ -16105,9 +16103,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (type === intrinsicMarkerType) { const typeKind = intrinsicTypeKinds.get(symbol.escapedName as string); if (typeKind !== undefined && typeArguments && typeArguments.length === 1) { - return typeKind === IntrinsicTypeKind.NoInfer ? getNoInferType(typeArguments[0]) : - typeKind === IntrinsicTypeKind.Deferred ? getDeferredCallbackType(typeArguments[0], aliasSymbol, aliasTypeArguments) : - getStringMappingType(symbol, typeArguments[0]); + return typeKind === IntrinsicTypeKind.NoInfer ? getNoInferType(typeArguments[0]) : getStringMappingType(symbol, typeArguments[0]); } } const links = getSymbolLinks(symbol); @@ -16120,27 +16116,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return instantiation; } - function getDeferredCallbackType(type: Type, aliasSymbol: Symbol | undefined, aliasTypeArguments: readonly Type[] | undefined) { - if (type.flags & TypeFlags.Object) { - const key = `F${getTypeId(type)}${getAliasId(aliasSymbol, aliasTypeArguments)}`; - return getCachedType(key) ?? setCachedType(key, createDeferredCallbackType(type as ObjectType, aliasSymbol, aliasTypeArguments)); - } - return type; - } - - function createDeferredCallbackType(type: ObjectType, aliasSymbol: Symbol | undefined, aliasTypeArguments: readonly Type[] | undefined) { - const resolved = resolveStructuredTypeMembers(type); - const result = createObjectType(ObjectFlags.Anonymous | ObjectFlags.DeferredCallback, type.symbol); - result.members = resolved.members; - result.properties = resolved.properties; - result.callSignatures = resolved.callSignatures; - result.constructSignatures = resolved.constructSignatures; - result.indexInfos = resolved.indexInfos; - result.aliasSymbol = aliasSymbol; - result.aliasTypeArguments = aliasTypeArguments; - return result; - } - /** * Get type from reference to type alias. When a type alias is generic, the declared type of the type alias may include * references to the type parameters of the alias. We replace those with the actual type arguments by instantiating the @@ -28190,7 +28165,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // circularities. Instead, we simply check if any signature has a deferred callback marker in the // particular argument position. signatures ??= getSignaturesOfType(getTypeOfExpression(flow.node.expression), SignatureKind.Call); - if (!some(signatures, sig => !!(getObjectFlags(getTypeAtPosition(sig, i)) & ObjectFlags.DeferredCallback))) { + if (!some(signatures, sig => !!(getModifiersAtPosition(sig, i) & ModifierFlags.Deferred))) { const lambdaType = getTypeFromFlowType(getTypeAtFlowNode(lambda.returnFlowNode)); if (lambdaType !== initialType) { lambdaTypes ??= [initialType]; @@ -37257,6 +37232,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return elementType && isTypeAny(elementType) ? anyType : restType; } + function getModifiersAtPosition(signature: Signature, pos: number) { + const index = pos < signature.parameters.length ? pos : signatureHasRestParameter(signature) ? signature.parameters.length - 1 : -1; + return index >= 0 ? getDeclarationModifierFlagsFromSymbol(signature.parameters[index]) : ModifierFlags.None; + } + // Return the number of parameters in a signature. The rest parameter, if present, counts as one // parameter. For example, the parameter count of (x: number, y: number, ...z: string[]) is 3 and // the parameter count of (x: number, ...args: [number, ...string[], boolean])) is also 3. In the @@ -40570,6 +40550,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { error(node.name, Diagnostics.constructor_cannot_be_used_as_a_parameter_property_name); } } + if (hasSyntacticModifier(node, ModifierFlags.Deferred)) { + const funcType = node.dotDotDotToken ? createArrayType(globalFunctionType, /*readonly*/ true) : globalFunctionType; + if (!isTypeAssignableTo(getTypeOfSymbol(node.symbol), funcType)) { + error(node, Diagnostics.A_deferred_parameter_must_have_a_function_type); + } + } if (!node.initializer && isOptionalDeclaration(node) && isBindingPattern(node.name) && (func as FunctionLikeDeclaration).body) { error(node, Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature); } @@ -50151,6 +50137,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { flags |= inOutFlag; break; } + + case SyntaxKind.DeferredKeyword: + if (node.kind !== SyntaxKind.Parameter) { + return grammarErrorOnNode(modifier, Diagnostics.deferred_modifier_can_only_appear_on_a_parameter_declaration); + } + if (flags & ModifierFlags.Deferred) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "deferred"); + } + flags |= ModifierFlags.Deferred; + break; } } } diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index e74033719b5b8..e1570dd8fd5fd 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -971,6 +971,10 @@ "category": "Error", "code": 1293 }, + "'deferred' modifier can only appear on a parameter declaration.": { + "category": "Error", + "code": 1294 + }, "'with' statements are not allowed in an async function block.": { "category": "Error", @@ -3911,6 +3915,10 @@ "category": "Error", "code": 2868 }, + "A 'deferred' parameter must have a function type.": { + "category": "Error", + "code": 2869 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts index 9fcd2a4acf7c1..71f6f3cf13a24 100644 --- a/src/compiler/factory/nodeFactory.ts +++ b/src/compiler/factory/nodeFactory.ts @@ -1471,6 +1471,7 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode case SyntaxKind.ReadonlyKeyword: case SyntaxKind.AbstractKeyword: case SyntaxKind.DeclareKeyword: + case SyntaxKind.DeferredKeyword: case SyntaxKind.ConstKeyword: case SyntaxKind.AnyKeyword: case SyntaxKind.NumberKeyword: @@ -1566,6 +1567,7 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode if (flags & ModifierFlags.Async) result.push(createModifier(SyntaxKind.AsyncKeyword)); if (flags & ModifierFlags.In) result.push(createModifier(SyntaxKind.InKeyword)); if (flags & ModifierFlags.Out) result.push(createModifier(SyntaxKind.OutKeyword)); + if (flags & ModifierFlags.Deferred) result.push(createModifier(SyntaxKind.DeferredKeyword)); return result.length ? result : undefined; } diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 09f4ed4ff6f3d..deec24a550576 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -3322,6 +3322,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg case SyntaxKind.ProtectedKeyword: case SyntaxKind.ReadonlyKeyword: case SyntaxKind.DeclareKeyword: + case SyntaxKind.DeferredKeyword: case SyntaxKind.AbstractKeyword: case SyntaxKind.OverrideKeyword: case SyntaxKind.InKeyword: diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index ad6928331f26d..4387895c59229 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -148,6 +148,7 @@ export const textToKeywordObj: MapLike = { debugger: SyntaxKind.DebuggerKeyword, declare: SyntaxKind.DeclareKeyword, default: SyntaxKind.DefaultKeyword, + deferred: SyntaxKind.DeferredKeyword, delete: SyntaxKind.DeleteKeyword, do: SyntaxKind.DoKeyword, else: SyntaxKind.ElseKeyword, diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index 668da90d8e696..d4735af6db5b5 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -661,6 +661,7 @@ export function transformTypeScript(context: TransformationContext) { case SyntaxKind.OverrideKeyword: case SyntaxKind.ConstKeyword: case SyntaxKind.DeclareKeyword: + case SyntaxKind.DeferredKeyword: case SyntaxKind.ReadonlyKeyword: case SyntaxKind.InKeyword: case SyntaxKind.OutKeyword: diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 6f69adc86759c..76ae32f94b497 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -196,6 +196,7 @@ export const enum SyntaxKind { BooleanKeyword, ConstructorKeyword, DeclareKeyword, + DeferredKeyword, GetKeyword, InferKeyword, IntrinsicKeyword, @@ -598,6 +599,7 @@ export type KeywordSyntaxKind = | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword + | SyntaxKind.DeferredKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword @@ -669,6 +671,7 @@ export type ModifierSyntaxKind = | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword + | SyntaxKind.DeferredKeyword | SyntaxKind.ExportKeyword | SyntaxKind.InKeyword | SyntaxKind.PrivateKeyword @@ -865,10 +868,11 @@ export const enum ModifierFlags { Const = 1 << 12, // Const enum In = 1 << 13, // Contravariance modifier Out = 1 << 14, // Covariance modifier - Decorator = 1 << 15, // Contains a decorator. + Deferred = 1 << 15, // Parameter + Decorator = 1 << 16, // Contains a decorator. // JSDoc-only modifiers - Deprecated = 1 << 16, // Deprecated tag. + Deprecated = 1 << 17, // Deprecated tag. // Cache-only JSDoc-modifiers. Should match order of Syntactic/JSDoc modifiers, above. /** @internal */ JSDocPublic = 1 << 23, // if this value changes, `selectEffectiveModifierFlags` must change accordingly @@ -878,7 +882,7 @@ export const enum ModifierFlags { /** @internal */ JSDocOverride = 1 << 27, /** @internal */ SyntacticOrJSDocModifiers = Public | Private | Protected | Readonly | Override, - /** @internal */ SyntacticOnlyModifiers = Export | Ambient | Abstract | Static | Accessor | Async | Default | Const | In | Out | Decorator, + /** @internal */ SyntacticOnlyModifiers = Export | Ambient | Abstract | Static | Accessor | Async | Default | Const | In | Out | Deferred | Decorator, /** @internal */ SyntacticModifiers = SyntacticOrJSDocModifiers | SyntacticOnlyModifiers, /** @internal */ JSDocCacheOnlyModifiers = JSDocPublic | JSDocPrivate | JSDocProtected | JSDocReadonly | JSDocOverride, /** @internal */ JSDocOnlyModifiers = Deprecated, @@ -892,9 +896,9 @@ export const enum ModifierFlags { ParameterPropertyModifier = AccessibilityModifier | Readonly | Override, NonPublicAccessibilityModifier = Private | Protected, - TypeScriptModifier = Ambient | Public | Private | Protected | Readonly | Abstract | Const | Override | In | Out, + TypeScriptModifier = Ambient | Public | Private | Protected | Readonly | Abstract | Const | Override | In | Out | Deferred, ExportDefault = Export | Default, - All = Export | Ambient | Public | Private | Protected | Static | Readonly | Abstract | Accessor | Async | Default | Const | Deprecated | Override | In | Out | Decorator, + All = Export | Ambient | Public | Private | Protected | Static | Readonly | Abstract | Accessor | Async | Default | Const | Deprecated | Override | In | Out | Deferred | Decorator, Modifier = All & ~Decorator, } @@ -1620,6 +1624,7 @@ export type AsyncKeyword = ModifierToken; export type ConstKeyword = ModifierToken; export type DeclareKeyword = ModifierToken; export type DefaultKeyword = ModifierToken; +export type DeferredKeyword = ModifierToken; export type ExportKeyword = ModifierToken; export type InKeyword = ModifierToken; export type PrivateKeyword = ModifierToken; @@ -1637,6 +1642,7 @@ export type Modifier = | ConstKeyword | DeclareKeyword | DefaultKeyword + | DeferredKeyword | ExportKeyword | InKeyword | PrivateKeyword @@ -6389,7 +6395,6 @@ export const enum ObjectFlags { /** @internal */ IdenticalBaseTypeExists = 1 << 26, // has a defined cachedEquivalentBaseType member SingleSignatureType = 1 << 27, // A single signature type extracted from a potentially broader type - DeferredCallback = 1 << 28, // Function type with Deferred marker // Flags that require TypeFlags.UnionOrIntersection or TypeFlags.Substitution /** @internal */ diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 918a7974c0c7e..04c2eb3b06456 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -7159,6 +7159,8 @@ export function modifierToFlag(token: SyntaxKind): ModifierFlags { return ModifierFlags.In; case SyntaxKind.OutKeyword: return ModifierFlags.Out; + case SyntaxKind.DeferredKeyword: + return ModifierFlags.Deferred; case SyntaxKind.Decorator: return ModifierFlags.Decorator; } diff --git a/src/compiler/utilitiesPublic.ts b/src/compiler/utilitiesPublic.ts index 2ff6e7adaa867..1bca593edd247 100644 --- a/src/compiler/utilitiesPublic.ts +++ b/src/compiler/utilitiesPublic.ts @@ -1568,6 +1568,7 @@ export function isModifierKind(token: SyntaxKind): token is Modifier["kind"] { case SyntaxKind.ConstKeyword: case SyntaxKind.DeclareKeyword: case SyntaxKind.DefaultKeyword: + case SyntaxKind.DeferredKeyword: case SyntaxKind.ExportKeyword: case SyntaxKind.InKeyword: case SyntaxKind.PublicKeyword: diff --git a/src/harness/fourslashInterfaceImpl.ts b/src/harness/fourslashInterfaceImpl.ts index 7400966d833ab..f04ac4594f918 100644 --- a/src/harness/fourslashInterfaceImpl.ts +++ b/src/harness/fourslashInterfaceImpl.ts @@ -1210,7 +1210,6 @@ export namespace Completion { typeEntry("Capitalize"), typeEntry("Uncapitalize"), typeEntry("NoInfer"), - typeEntry("Deferred"), interfaceEntry("ThisType"), varEntry("ArrayBuffer"), interfaceEntry("ArrayBufferTypes"), diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index 3fc2031efd146..33bbb99147490 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -1654,11 +1654,6 @@ type Uncapitalize = intrinsic; */ type NoInfer = intrinsic; -/** - * Marker for deferred callbacks - */ -type Deferred any> = intrinsic; - /** * Marker for contextual 'this' type */ From 0288e180f4bd7b59a6b1186d9274a7ec8a7c3483 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 13 Jun 2024 07:14:32 -0700 Subject: [PATCH 12/30] Accept new baselines --- tests/baselines/reference/api/typescript.d.ts | 485 +++++++++--------- ...rtProvider_namespaceSameNameAsIntrinsic.js | 6 - .../pasteEdits_revertUpdatedFile.js | 6 - 3 files changed, 244 insertions(+), 253 deletions(-) diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index 414cb8a6bdf3e..ed7b04076f546 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -3785,229 +3785,230 @@ declare namespace ts { BooleanKeyword = 136, ConstructorKeyword = 137, DeclareKeyword = 138, - GetKeyword = 139, - InferKeyword = 140, - IntrinsicKeyword = 141, - IsKeyword = 142, - KeyOfKeyword = 143, - ModuleKeyword = 144, - NamespaceKeyword = 145, - NeverKeyword = 146, - OutKeyword = 147, - ReadonlyKeyword = 148, - RequireKeyword = 149, - NumberKeyword = 150, - ObjectKeyword = 151, - SatisfiesKeyword = 152, - SetKeyword = 153, - StringKeyword = 154, - SymbolKeyword = 155, - TypeKeyword = 156, - UndefinedKeyword = 157, - UniqueKeyword = 158, - UnknownKeyword = 159, - UsingKeyword = 160, - FromKeyword = 161, - GlobalKeyword = 162, - BigIntKeyword = 163, - OverrideKeyword = 164, - OfKeyword = 165, - QualifiedName = 166, - ComputedPropertyName = 167, - TypeParameter = 168, - Parameter = 169, - Decorator = 170, - PropertySignature = 171, - PropertyDeclaration = 172, - MethodSignature = 173, - MethodDeclaration = 174, - ClassStaticBlockDeclaration = 175, - Constructor = 176, - GetAccessor = 177, - SetAccessor = 178, - CallSignature = 179, - ConstructSignature = 180, - IndexSignature = 181, - TypePredicate = 182, - TypeReference = 183, - FunctionType = 184, - ConstructorType = 185, - TypeQuery = 186, - TypeLiteral = 187, - ArrayType = 188, - TupleType = 189, - OptionalType = 190, - RestType = 191, - UnionType = 192, - IntersectionType = 193, - ConditionalType = 194, - InferType = 195, - ParenthesizedType = 196, - ThisType = 197, - TypeOperator = 198, - IndexedAccessType = 199, - MappedType = 200, - LiteralType = 201, - NamedTupleMember = 202, - TemplateLiteralType = 203, - TemplateLiteralTypeSpan = 204, - ImportType = 205, - ObjectBindingPattern = 206, - ArrayBindingPattern = 207, - BindingElement = 208, - ArrayLiteralExpression = 209, - ObjectLiteralExpression = 210, - PropertyAccessExpression = 211, - ElementAccessExpression = 212, - CallExpression = 213, - NewExpression = 214, - TaggedTemplateExpression = 215, - TypeAssertionExpression = 216, - ParenthesizedExpression = 217, - FunctionExpression = 218, - ArrowFunction = 219, - DeleteExpression = 220, - TypeOfExpression = 221, - VoidExpression = 222, - AwaitExpression = 223, - PrefixUnaryExpression = 224, - PostfixUnaryExpression = 225, - BinaryExpression = 226, - ConditionalExpression = 227, - TemplateExpression = 228, - YieldExpression = 229, - SpreadElement = 230, - ClassExpression = 231, - OmittedExpression = 232, - ExpressionWithTypeArguments = 233, - AsExpression = 234, - NonNullExpression = 235, - MetaProperty = 236, - SyntheticExpression = 237, - SatisfiesExpression = 238, - TemplateSpan = 239, - SemicolonClassElement = 240, - Block = 241, - EmptyStatement = 242, - VariableStatement = 243, - ExpressionStatement = 244, - IfStatement = 245, - DoStatement = 246, - WhileStatement = 247, - ForStatement = 248, - ForInStatement = 249, - ForOfStatement = 250, - ContinueStatement = 251, - BreakStatement = 252, - ReturnStatement = 253, - WithStatement = 254, - SwitchStatement = 255, - LabeledStatement = 256, - ThrowStatement = 257, - TryStatement = 258, - DebuggerStatement = 259, - VariableDeclaration = 260, - VariableDeclarationList = 261, - FunctionDeclaration = 262, - ClassDeclaration = 263, - InterfaceDeclaration = 264, - TypeAliasDeclaration = 265, - EnumDeclaration = 266, - ModuleDeclaration = 267, - ModuleBlock = 268, - CaseBlock = 269, - NamespaceExportDeclaration = 270, - ImportEqualsDeclaration = 271, - ImportDeclaration = 272, - ImportClause = 273, - NamespaceImport = 274, - NamedImports = 275, - ImportSpecifier = 276, - ExportAssignment = 277, - ExportDeclaration = 278, - NamedExports = 279, - NamespaceExport = 280, - ExportSpecifier = 281, - MissingDeclaration = 282, - ExternalModuleReference = 283, - JsxElement = 284, - JsxSelfClosingElement = 285, - JsxOpeningElement = 286, - JsxClosingElement = 287, - JsxFragment = 288, - JsxOpeningFragment = 289, - JsxClosingFragment = 290, - JsxAttribute = 291, - JsxAttributes = 292, - JsxSpreadAttribute = 293, - JsxExpression = 294, - JsxNamespacedName = 295, - CaseClause = 296, - DefaultClause = 297, - HeritageClause = 298, - CatchClause = 299, - ImportAttributes = 300, - ImportAttribute = 301, - /** @deprecated */ AssertClause = 300, - /** @deprecated */ AssertEntry = 301, - /** @deprecated */ ImportTypeAssertionContainer = 302, - PropertyAssignment = 303, - ShorthandPropertyAssignment = 304, - SpreadAssignment = 305, - EnumMember = 306, - SourceFile = 307, - Bundle = 308, - JSDocTypeExpression = 309, - JSDocNameReference = 310, - JSDocMemberName = 311, - JSDocAllType = 312, - JSDocUnknownType = 313, - JSDocNullableType = 314, - JSDocNonNullableType = 315, - JSDocOptionalType = 316, - JSDocFunctionType = 317, - JSDocVariadicType = 318, - JSDocNamepathType = 319, - JSDoc = 320, + DeferredKeyword = 139, + GetKeyword = 140, + InferKeyword = 141, + IntrinsicKeyword = 142, + IsKeyword = 143, + KeyOfKeyword = 144, + ModuleKeyword = 145, + NamespaceKeyword = 146, + NeverKeyword = 147, + OutKeyword = 148, + ReadonlyKeyword = 149, + RequireKeyword = 150, + NumberKeyword = 151, + ObjectKeyword = 152, + SatisfiesKeyword = 153, + SetKeyword = 154, + StringKeyword = 155, + SymbolKeyword = 156, + TypeKeyword = 157, + UndefinedKeyword = 158, + UniqueKeyword = 159, + UnknownKeyword = 160, + UsingKeyword = 161, + FromKeyword = 162, + GlobalKeyword = 163, + BigIntKeyword = 164, + OverrideKeyword = 165, + OfKeyword = 166, + QualifiedName = 167, + ComputedPropertyName = 168, + TypeParameter = 169, + Parameter = 170, + Decorator = 171, + PropertySignature = 172, + PropertyDeclaration = 173, + MethodSignature = 174, + MethodDeclaration = 175, + ClassStaticBlockDeclaration = 176, + Constructor = 177, + GetAccessor = 178, + SetAccessor = 179, + CallSignature = 180, + ConstructSignature = 181, + IndexSignature = 182, + TypePredicate = 183, + TypeReference = 184, + FunctionType = 185, + ConstructorType = 186, + TypeQuery = 187, + TypeLiteral = 188, + ArrayType = 189, + TupleType = 190, + OptionalType = 191, + RestType = 192, + UnionType = 193, + IntersectionType = 194, + ConditionalType = 195, + InferType = 196, + ParenthesizedType = 197, + ThisType = 198, + TypeOperator = 199, + IndexedAccessType = 200, + MappedType = 201, + LiteralType = 202, + NamedTupleMember = 203, + TemplateLiteralType = 204, + TemplateLiteralTypeSpan = 205, + ImportType = 206, + ObjectBindingPattern = 207, + ArrayBindingPattern = 208, + BindingElement = 209, + ArrayLiteralExpression = 210, + ObjectLiteralExpression = 211, + PropertyAccessExpression = 212, + ElementAccessExpression = 213, + CallExpression = 214, + NewExpression = 215, + TaggedTemplateExpression = 216, + TypeAssertionExpression = 217, + ParenthesizedExpression = 218, + FunctionExpression = 219, + ArrowFunction = 220, + DeleteExpression = 221, + TypeOfExpression = 222, + VoidExpression = 223, + AwaitExpression = 224, + PrefixUnaryExpression = 225, + PostfixUnaryExpression = 226, + BinaryExpression = 227, + ConditionalExpression = 228, + TemplateExpression = 229, + YieldExpression = 230, + SpreadElement = 231, + ClassExpression = 232, + OmittedExpression = 233, + ExpressionWithTypeArguments = 234, + AsExpression = 235, + NonNullExpression = 236, + MetaProperty = 237, + SyntheticExpression = 238, + SatisfiesExpression = 239, + TemplateSpan = 240, + SemicolonClassElement = 241, + Block = 242, + EmptyStatement = 243, + VariableStatement = 244, + ExpressionStatement = 245, + IfStatement = 246, + DoStatement = 247, + WhileStatement = 248, + ForStatement = 249, + ForInStatement = 250, + ForOfStatement = 251, + ContinueStatement = 252, + BreakStatement = 253, + ReturnStatement = 254, + WithStatement = 255, + SwitchStatement = 256, + LabeledStatement = 257, + ThrowStatement = 258, + TryStatement = 259, + DebuggerStatement = 260, + VariableDeclaration = 261, + VariableDeclarationList = 262, + FunctionDeclaration = 263, + ClassDeclaration = 264, + InterfaceDeclaration = 265, + TypeAliasDeclaration = 266, + EnumDeclaration = 267, + ModuleDeclaration = 268, + ModuleBlock = 269, + CaseBlock = 270, + NamespaceExportDeclaration = 271, + ImportEqualsDeclaration = 272, + ImportDeclaration = 273, + ImportClause = 274, + NamespaceImport = 275, + NamedImports = 276, + ImportSpecifier = 277, + ExportAssignment = 278, + ExportDeclaration = 279, + NamedExports = 280, + NamespaceExport = 281, + ExportSpecifier = 282, + MissingDeclaration = 283, + ExternalModuleReference = 284, + JsxElement = 285, + JsxSelfClosingElement = 286, + JsxOpeningElement = 287, + JsxClosingElement = 288, + JsxFragment = 289, + JsxOpeningFragment = 290, + JsxClosingFragment = 291, + JsxAttribute = 292, + JsxAttributes = 293, + JsxSpreadAttribute = 294, + JsxExpression = 295, + JsxNamespacedName = 296, + CaseClause = 297, + DefaultClause = 298, + HeritageClause = 299, + CatchClause = 300, + ImportAttributes = 301, + ImportAttribute = 302, + /** @deprecated */ AssertClause = 301, + /** @deprecated */ AssertEntry = 302, + /** @deprecated */ ImportTypeAssertionContainer = 303, + PropertyAssignment = 304, + ShorthandPropertyAssignment = 305, + SpreadAssignment = 306, + EnumMember = 307, + SourceFile = 308, + Bundle = 309, + JSDocTypeExpression = 310, + JSDocNameReference = 311, + JSDocMemberName = 312, + JSDocAllType = 313, + JSDocUnknownType = 314, + JSDocNullableType = 315, + JSDocNonNullableType = 316, + JSDocOptionalType = 317, + JSDocFunctionType = 318, + JSDocVariadicType = 319, + JSDocNamepathType = 320, + JSDoc = 321, /** @deprecated Use SyntaxKind.JSDoc */ - JSDocComment = 320, - JSDocText = 321, - JSDocTypeLiteral = 322, - JSDocSignature = 323, - JSDocLink = 324, - JSDocLinkCode = 325, - JSDocLinkPlain = 326, - JSDocTag = 327, - JSDocAugmentsTag = 328, - JSDocImplementsTag = 329, - JSDocAuthorTag = 330, - JSDocDeprecatedTag = 331, - JSDocClassTag = 332, - JSDocPublicTag = 333, - JSDocPrivateTag = 334, - JSDocProtectedTag = 335, - JSDocReadonlyTag = 336, - JSDocOverrideTag = 337, - JSDocCallbackTag = 338, - JSDocOverloadTag = 339, - JSDocEnumTag = 340, - JSDocParameterTag = 341, - JSDocReturnTag = 342, - JSDocThisTag = 343, - JSDocTypeTag = 344, - JSDocTemplateTag = 345, - JSDocTypedefTag = 346, - JSDocSeeTag = 347, - JSDocPropertyTag = 348, - JSDocThrowsTag = 349, - JSDocSatisfiesTag = 350, - JSDocImportTag = 351, - SyntaxList = 352, - NotEmittedStatement = 353, - PartiallyEmittedExpression = 354, - CommaListExpression = 355, - SyntheticReferenceExpression = 356, - Count = 357, + JSDocComment = 321, + JSDocText = 322, + JSDocTypeLiteral = 323, + JSDocSignature = 324, + JSDocLink = 325, + JSDocLinkCode = 326, + JSDocLinkPlain = 327, + JSDocTag = 328, + JSDocAugmentsTag = 329, + JSDocImplementsTag = 330, + JSDocAuthorTag = 331, + JSDocDeprecatedTag = 332, + JSDocClassTag = 333, + JSDocPublicTag = 334, + JSDocPrivateTag = 335, + JSDocProtectedTag = 336, + JSDocReadonlyTag = 337, + JSDocOverrideTag = 338, + JSDocCallbackTag = 339, + JSDocOverloadTag = 340, + JSDocEnumTag = 341, + JSDocParameterTag = 342, + JSDocReturnTag = 343, + JSDocThisTag = 344, + JSDocTypeTag = 345, + JSDocTemplateTag = 346, + JSDocTypedefTag = 347, + JSDocSeeTag = 348, + JSDocPropertyTag = 349, + JSDocThrowsTag = 350, + JSDocSatisfiesTag = 351, + JSDocImportTag = 352, + SyntaxList = 353, + NotEmittedStatement = 354, + PartiallyEmittedExpression = 355, + CommaListExpression = 356, + SyntheticReferenceExpression = 357, + Count = 358, FirstAssignment = 64, LastAssignment = 79, FirstCompoundAssignment = 65, @@ -4015,15 +4016,15 @@ declare namespace ts { FirstReservedWord = 83, LastReservedWord = 118, FirstKeyword = 83, - LastKeyword = 165, + LastKeyword = 166, FirstFutureReservedWord = 119, LastFutureReservedWord = 127, - FirstTypeNode = 182, - LastTypeNode = 205, + FirstTypeNode = 183, + LastTypeNode = 206, FirstPunctuation = 19, LastPunctuation = 79, FirstToken = 0, - LastToken = 165, + LastToken = 166, FirstTriviaToken = 2, LastTriviaToken = 7, FirstLiteralToken = 9, @@ -4032,13 +4033,13 @@ declare namespace ts { LastTemplateToken = 18, FirstBinaryOperator = 30, LastBinaryOperator = 79, - FirstStatement = 243, - LastStatement = 259, - FirstNode = 166, - FirstJSDocNode = 309, - LastJSDocNode = 351, - FirstJSDocTagNode = 327, - LastJSDocTagNode = 351, + FirstStatement = 244, + LastStatement = 260, + FirstNode = 167, + FirstJSDocNode = 310, + LastJSDocNode = 352, + FirstJSDocTagNode = 328, + LastJSDocTagNode = 352, } type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia; type LiteralSyntaxKind = SyntaxKind.NumericLiteral | SyntaxKind.BigIntLiteral | SyntaxKind.StringLiteral | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.RegularExpressionLiteral | SyntaxKind.NoSubstitutionTemplateLiteral; @@ -4126,6 +4127,7 @@ declare namespace ts { | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword + | SyntaxKind.DeferredKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword @@ -4189,7 +4191,7 @@ declare namespace ts { | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; - type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AccessorKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.InKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.StaticKeyword; + type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AccessorKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeferredKeyword | SyntaxKind.ExportKeyword | SyntaxKind.InKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.StaticKeyword; type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword; type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PseudoLiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind; type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken; @@ -4245,17 +4247,18 @@ declare namespace ts { Const = 4096, In = 8192, Out = 16384, - Decorator = 32768, - Deprecated = 65536, + Deferred = 32768, + Decorator = 65536, + Deprecated = 131072, HasComputedJSDocModifiers = 268435456, HasComputedFlags = 536870912, AccessibilityModifier = 7, ParameterPropertyModifier = 31, NonPublicAccessibilityModifier = 6, - TypeScriptModifier = 28895, + TypeScriptModifier = 61663, ExportDefault = 2080, - All = 131071, - Modifier = 98303, + All = 262143, + Modifier = 196607, } enum JsxFlags { None = 0, @@ -4404,6 +4407,7 @@ declare namespace ts { type ConstKeyword = ModifierToken; type DeclareKeyword = ModifierToken; type DefaultKeyword = ModifierToken; + type DeferredKeyword = ModifierToken; type ExportKeyword = ModifierToken; type InKeyword = ModifierToken; type PrivateKeyword = ModifierToken; @@ -4413,7 +4417,7 @@ declare namespace ts { type OutKeyword = ModifierToken; type OverrideKeyword = ModifierToken; type StaticKeyword = ModifierToken; - type Modifier = AbstractKeyword | AccessorKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | InKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OutKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword; + type Modifier = AbstractKeyword | AccessorKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | DeferredKeyword | ExportKeyword | InKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OutKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword; type ModifierLike = Modifier | Decorator; type AccessibilityModifier = PublicKeyword | PrivateKeyword | ProtectedKeyword; type ParameterPropertyModifier = AccessibilityModifier | ReadonlyKeyword; @@ -6647,7 +6651,6 @@ declare namespace ts { ObjectRestType = 4194304, InstantiationExpressionType = 8388608, SingleSignatureType = 134217728, - DeferredCallback = 268435456, } interface ObjectType extends Type { objectFlags: ObjectFlags; diff --git a/tests/baselines/reference/tsserver/fourslashServer/autoImportProvider_namespaceSameNameAsIntrinsic.js b/tests/baselines/reference/tsserver/fourslashServer/autoImportProvider_namespaceSameNameAsIntrinsic.js index ac7c72244be5c..ffb5faecf4d5f 100644 --- a/tests/baselines/reference/tsserver/fourslashServer/autoImportProvider_namespaceSameNameAsIntrinsic.js +++ b/tests/baselines/reference/tsserver/fourslashServer/autoImportProvider_namespaceSameNameAsIntrinsic.js @@ -584,12 +584,6 @@ Info seq [hh:mm:ss:mss] response: "kindModifiers": "declare", "sortText": "15" }, - { - "name": "Deferred", - "kind": "type", - "kindModifiers": "declare", - "sortText": "15" - }, { "name": "Error", "kind": "var", diff --git a/tests/baselines/reference/tsserver/fourslashServer/pasteEdits_revertUpdatedFile.js b/tests/baselines/reference/tsserver/fourslashServer/pasteEdits_revertUpdatedFile.js index 0b4906ca49baa..3386cebb96943 100644 --- a/tests/baselines/reference/tsserver/fourslashServer/pasteEdits_revertUpdatedFile.js +++ b/tests/baselines/reference/tsserver/fourslashServer/pasteEdits_revertUpdatedFile.js @@ -607,12 +607,6 @@ Info seq [hh:mm:ss:mss] response: "kindModifiers": "declare", "sortText": "15" }, - { - "name": "Deferred", - "kind": "type", - "kindModifiers": "declare", - "sortText": "15" - }, { "name": "Error", "kind": "var", From fc9c454ccfd318f19156c399c22e882e7d5100f0 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Sun, 16 Jun 2024 09:24:06 +0200 Subject: [PATCH 13/30] Use comparable relation for check + fix parsing issue --- src/compiler/checker.ts | 12 ++++++------ src/compiler/diagnosticMessages.json | 2 +- src/compiler/parser.ts | 1 + 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index a7a0727e7d8ea..30b51d561acf2 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -40550,12 +40550,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { error(node.name, Diagnostics.constructor_cannot_be_used_as_a_parameter_property_name); } } - if (hasSyntacticModifier(node, ModifierFlags.Deferred)) { - const funcType = node.dotDotDotToken ? createArrayType(globalFunctionType, /*readonly*/ true) : globalFunctionType; - if (!isTypeAssignableTo(getTypeOfSymbol(node.symbol), funcType)) { - error(node, Diagnostics.A_deferred_parameter_must_have_a_function_type); - } - } if (!node.initializer && isOptionalDeclaration(node) && isBindingPattern(node.name) && (func as FunctionLikeDeclaration).body) { error(node, Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature); } @@ -40579,6 +40573,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (node.dotDotDotToken && !isBindingPattern(node.name) && !isTypeAssignableTo(getReducedType(getTypeOfSymbol(node.symbol)), anyReadonlyArrayType)) { error(node, Diagnostics.A_rest_parameter_must_be_of_an_array_type); } + if (hasSyntacticModifier(node, ModifierFlags.Deferred)) { + const funcType = node.dotDotDotToken ? createArrayType(globalFunctionType, /*readonly*/ true) : globalFunctionType; + if (!areTypesComparable(getTypeOfSymbol(node.symbol), funcType)) { + error(node, Diagnostics.A_deferred_parameter_must_have_a_type_that_permits_functions); + } + } } function checkTypePredicate(node: TypePredicateNode): void { diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index e1570dd8fd5fd..7e1a577ae0c4d 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -3915,7 +3915,7 @@ "category": "Error", "code": 2868 }, - "A 'deferred' parameter must have a function type.": { + "A 'deferred' parameter must have a type that permits functions.": { "category": "Error", "code": 2869 }, diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 56b958bcf3b74..37d69ec340fdb 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -4842,6 +4842,7 @@ namespace Parser { // Skip modifiers parseModifiers(/*allowDecorators*/ false); } + parseOptional(SyntaxKind.DotDotDotToken); if (isIdentifier() || token() === SyntaxKind.ThisKeyword) { nextToken(); return true; From b6fb469b7fb6ca4cc48b396cf64db885228b4693 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Sun, 16 Jun 2024 09:49:19 +0200 Subject: [PATCH 14/30] Add 'deferred' modifiers to Promise methods --- src/lib/es2018.promise.d.ts | 2 +- src/lib/es5.d.ts | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/lib/es2018.promise.d.ts b/src/lib/es2018.promise.d.ts index 070c4972f1141..49171882e6623 100644 --- a/src/lib/es2018.promise.d.ts +++ b/src/lib/es2018.promise.d.ts @@ -8,5 +8,5 @@ interface Promise { * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). * @returns A Promise for the completion of the callback. */ - finally(onfinally?: (() => void) | undefined | null): Promise; + finally(deferred onfinally?: (() => void) | undefined | null): Promise; } diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index 33bbb99147490..0ed54745a74f4 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -1516,7 +1516,7 @@ interface PromiseLike { * @param onrejected The callback to execute when the Promise is rejected. * @returns A Promise for the completion of which ever callback is executed. */ - then(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): PromiseLike; + then(deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): PromiseLike; } /** @@ -1529,14 +1529,14 @@ interface Promise { * @param onrejected The callback to execute when the Promise is rejected. * @returns A Promise for the completion of which ever callback is executed. */ - then(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; + then(deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; /** * Attaches a callback for only the rejection of the Promise. * @param onrejected The callback to execute when the Promise is rejected. * @returns A Promise for the completion of the callback. */ - catch(onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; + catch(deferred onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; } /** From 41883a1fd06377b04f82d7372d7dffd307d2f8d3 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 17 Jun 2024 10:08:39 +0200 Subject: [PATCH 15/30] Accept new baselines --- .../goToTypeDefinition_promiseType.baseline.jsonc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/baselines/reference/goToTypeDefinition_promiseType.baseline.jsonc b/tests/baselines/reference/goToTypeDefinition_promiseType.baseline.jsonc index f84caf2e46250..8ff1e53037577 100644 --- a/tests/baselines/reference/goToTypeDefinition_promiseType.baseline.jsonc +++ b/tests/baselines/reference/goToTypeDefinition_promiseType.baseline.jsonc @@ -19,14 +19,14 @@ // * @param onrejected The callback to execute when the Promise is rejected. // * @returns A Promise for the completion of which ever callback is executed. // */ -// then(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; +// then(deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; // // /** // * Attaches a callback for only the rejection of the Promise. // * @param onrejected The callback to execute when the Promise is rejected. // * @returns A Promise for the completion of the callback. // */ -// catch(onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; +// catch(deferred onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; // }|> // // /** @@ -80,14 +80,14 @@ // * @param onrejected The callback to execute when the Promise is rejected. // * @returns A Promise for the completion of which ever callback is executed. // */ -// then(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; +// then(deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; // // /** // * Attaches a callback for only the rejection of the Promise. // * @param onrejected The callback to execute when the Promise is rejected. // * @returns A Promise for the completion of the callback. // */ -// catch(onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; +// catch(deferred onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; // }|> // // /** From 35aced632d6fe36754b8952389f86b36fe8170b4 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 20 Jun 2024 09:41:08 +0200 Subject: [PATCH 16/30] Validation, print back, support for JSDoc --- src/compiler/checker.ts | 14 ++++++++- src/compiler/factory/nodeFactory.ts | 7 +++++ src/compiler/factory/nodeTests.ts | 5 +++ src/compiler/parser.ts | 3 ++ src/compiler/types.ts | 48 +++++++++++++++++------------ src/compiler/utilities.ts | 20 +++++++----- src/compiler/utilitiesPublic.ts | 12 ++++++++ 7 files changed, 80 insertions(+), 29 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 30b51d561acf2..d7bc1157f7bd5 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7540,7 +7540,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const parameterType = getTypeOfSymbol(parameterSymbol); const parameterTypeNode = serializeTypeForDeclaration(context, parameterDeclaration, parameterType, parameterSymbol); - const modifiers = !(context.flags & NodeBuilderFlags.OmitParameterModifiers) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : undefined; + const modifiers = parameterDeclaration && canHaveModifiers(parameterDeclaration) && (!(context.flags & NodeBuilderFlags.OmitParameterModifiers) && preserveModifierFlags || hasSyntacticModifier(parameterDeclaration, ModifierFlags.Deferred)) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : undefined; const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & CheckFlags.RestParameter; const dotDotDotToken = isRest ? factory.createToken(SyntaxKind.DotDotDotToken) : undefined; const name = parameterToParameterDeclarationName(parameterSymbol, parameterDeclaration, context); @@ -50145,6 +50145,18 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (flags & ModifierFlags.Deferred) { return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "deferred"); } + if (flags & ModifierFlags.Public) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "deferred", "public"); + } + if (flags & ModifierFlags.Protected) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "deferred", "protected"); + } + if (flags & ModifierFlags.Private) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "deferred", "private"); + } + if (flags & ModifierFlags.Readonly) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "deferred", "readonly"); + } flags |= ModifierFlags.Deferred; break; } diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts index 71f6f3cf13a24..d712505a7a33e 100644 --- a/src/compiler/factory/nodeFactory.ts +++ b/src/compiler/factory/nodeFactory.ts @@ -222,6 +222,7 @@ import { JSDocCallbackTag, JSDocClassTag, JSDocComment, + JSDocDeferredTag, JSDocDeprecatedTag, JSDocEnumTag, JSDocFunctionType, @@ -938,6 +939,12 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode get updateJSDocDeprecatedTag() { return getJSDocSimpleTagUpdateFunction(SyntaxKind.JSDocDeprecatedTag); }, + get createJSDocDeferredTag() { + return getJSDocSimpleTagCreateFunction(SyntaxKind.JSDocDeferredTag); + }, + get updateJSDocDeferredTag() { + return getJSDocSimpleTagUpdateFunction(SyntaxKind.JSDocDeferredTag); + }, get createJSDocThrowsTag() { return getJSDocTypeLikeTagCreateFunction(SyntaxKind.JSDocThrowsTag); }, diff --git a/src/compiler/factory/nodeTests.ts b/src/compiler/factory/nodeTests.ts index cd31b63f81843..8d04d48212554 100644 --- a/src/compiler/factory/nodeTests.ts +++ b/src/compiler/factory/nodeTests.ts @@ -87,6 +87,7 @@ import { JSDocAuthorTag, JSDocCallbackTag, JSDocClassTag, + JSDocDeferredTag, JSDocDeprecatedTag, JSDocEnumTag, JSDocFunctionType, @@ -1132,6 +1133,10 @@ export function isJSDocDeprecatedTag(node: Node): node is JSDocDeprecatedTag { return node.kind === SyntaxKind.JSDocDeprecatedTag; } +export function isJSDocDeferredTag(node: Node): node is JSDocDeferredTag { + return node.kind === SyntaxKind.JSDocDeferredTag; +} + export function isJSDocSeeTag(node: Node): node is JSDocSeeTag { return node.kind === SyntaxKind.JSDocSeeTag; } diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 37d69ec340fdb..6ccbbe76dbd20 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -9057,6 +9057,9 @@ namespace Parser { hasDeprecatedTag = true; tag = parseSimpleTag(start, factory.createJSDocDeprecatedTag, tagName, margin, indentText); break; + case "deferred": + tag = parseSimpleTag(start, factory.createJSDocDeferredTag, tagName, margin, indentText); + break; case "this": tag = parseThisTag(start, tagName, margin, indentText); break; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 76ae32f94b497..5ae864fb89b88 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -421,6 +421,7 @@ export const enum SyntaxKind { JSDocImplementsTag, JSDocAuthorTag, JSDocDeprecatedTag, + JSDocDeferredTag, JSDocClassTag, JSDocPublicTag, JSDocPrivateTag, @@ -856,35 +857,36 @@ export const enum ModifierFlags { Protected = 1 << 2, // Property/Method Readonly = 1 << 3, // Property/Method Override = 1 << 4, // Override method. + Deferred = 1 << 5, // Parameter // Syntactic-only modifiers - Export = 1 << 5, // Declarations - Abstract = 1 << 6, // Class/Method/ConstructSignature - Ambient = 1 << 7, // Declarations - Static = 1 << 8, // Property/Method - Accessor = 1 << 9, // Property - Async = 1 << 10, // Property/Method/Function - Default = 1 << 11, // Function/Class (export default declaration) - Const = 1 << 12, // Const enum - In = 1 << 13, // Contravariance modifier - Out = 1 << 14, // Covariance modifier - Deferred = 1 << 15, // Parameter + Export = 1 << 6, // Declarations + Abstract = 1 << 7, // Class/Method/ConstructSignature + Ambient = 1 << 8, // Declarations + Static = 1 << 9, // Property/Method + Accessor = 1 << 10, // Property + Async = 1 << 11, // Property/Method/Function + Default = 1 << 12, // Function/Class (export default declaration) + Const = 1 << 13, // Const enum + In = 1 << 14, // Contravariance modifier + Out = 1 << 15, // Covariance modifier Decorator = 1 << 16, // Contains a decorator. // JSDoc-only modifiers Deprecated = 1 << 17, // Deprecated tag. // Cache-only JSDoc-modifiers. Should match order of Syntactic/JSDoc modifiers, above. - /** @internal */ JSDocPublic = 1 << 23, // if this value changes, `selectEffectiveModifierFlags` must change accordingly - /** @internal */ JSDocPrivate = 1 << 24, - /** @internal */ JSDocProtected = 1 << 25, - /** @internal */ JSDocReadonly = 1 << 26, - /** @internal */ JSDocOverride = 1 << 27, - - /** @internal */ SyntacticOrJSDocModifiers = Public | Private | Protected | Readonly | Override, - /** @internal */ SyntacticOnlyModifiers = Export | Ambient | Abstract | Static | Accessor | Async | Default | Const | In | Out | Deferred | Decorator, + /** @internal */ JSDocPublic = 1 << 22, // if this value changes, `selectEffectiveModifierFlags` must change accordingly + /** @internal */ JSDocPrivate = 1 << 23, + /** @internal */ JSDocProtected = 1 << 24, + /** @internal */ JSDocReadonly = 1 << 25, + /** @internal */ JSDocOverride = 1 << 26, + /** @internal */ JSDocDeferred = 1 << 27, + + /** @internal */ SyntacticOrJSDocModifiers = Public | Private | Protected | Readonly | Override | Deferred, + /** @internal */ SyntacticOnlyModifiers = Export | Ambient | Abstract | Static | Accessor | Async | Default | Const | In | Out | Decorator, /** @internal */ SyntacticModifiers = SyntacticOrJSDocModifiers | SyntacticOnlyModifiers, - /** @internal */ JSDocCacheOnlyModifiers = JSDocPublic | JSDocPrivate | JSDocProtected | JSDocReadonly | JSDocOverride, + /** @internal */ JSDocCacheOnlyModifiers = JSDocPublic | JSDocPrivate | JSDocProtected | JSDocReadonly | JSDocOverride | JSDocDeferred, /** @internal */ JSDocOnlyModifiers = Deprecated, /** @internal */ NonCacheOnlyModifiers = SyntacticOrJSDocModifiers | SyntacticOnlyModifiers | JSDocOnlyModifiers, @@ -3970,6 +3972,10 @@ export interface JSDocDeprecatedTag extends JSDocTag { kind: SyntaxKind.JSDocDeprecatedTag; } +export interface JSDocDeferredTag extends JSDocTag { + kind: SyntaxKind.JSDocDeferredTag; +} + export interface JSDocClassTag extends JSDocTag { readonly kind: SyntaxKind.JSDocClassTag; } @@ -8985,6 +8991,8 @@ export interface NodeFactory { updateJSDocUnknownTag(node: JSDocUnknownTag, tagName: Identifier, comment: string | NodeArray | undefined): JSDocUnknownTag; createJSDocDeprecatedTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeprecatedTag; updateJSDocDeprecatedTag(node: JSDocDeprecatedTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeprecatedTag; + createJSDocDeferredTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeferredTag; + updateJSDocDeferredTag(node: JSDocDeferredTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeferredTag; createJSDocOverrideTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocOverrideTag; updateJSDocOverrideTag(node: JSDocOverrideTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocOverrideTag; createJSDocThrowsTag(tagName: Identifier, typeExpression: JSDocTypeExpression | undefined, comment?: string | NodeArray): JSDocThrowsTag; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 04c2eb3b06456..3eb64dee33b91 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -170,6 +170,7 @@ import { getDirectoryPath, getImpliedNodeFormatForEmitWorker, getJSDocAugmentsTag, + getJSDocDeferredTagNoCache, getJSDocDeprecatedTagNoCache, getJSDocImplementsTags, getJSDocOverrideTagNoCache, @@ -7062,15 +7063,18 @@ export function getSyntacticModifierFlags(node: Node): ModifierFlags { function getRawJSDocModifierFlagsNoCache(node: Node): ModifierFlags { let flags = ModifierFlags.None; - if (!!node.parent && !isParameter(node)) { + if (node.parent) { if (isInJSFile(node)) { - if (getJSDocPublicTagNoCache(node)) flags |= ModifierFlags.JSDocPublic; - if (getJSDocPrivateTagNoCache(node)) flags |= ModifierFlags.JSDocPrivate; - if (getJSDocProtectedTagNoCache(node)) flags |= ModifierFlags.JSDocProtected; - if (getJSDocReadonlyTagNoCache(node)) flags |= ModifierFlags.JSDocReadonly; - if (getJSDocOverrideTagNoCache(node)) flags |= ModifierFlags.JSDocOverride; + if (!isParameter(node)) { + if (getJSDocPublicTagNoCache(node)) flags |= ModifierFlags.JSDocPublic; + if (getJSDocPrivateTagNoCache(node)) flags |= ModifierFlags.JSDocPrivate; + if (getJSDocProtectedTagNoCache(node)) flags |= ModifierFlags.JSDocProtected; + if (getJSDocReadonlyTagNoCache(node)) flags |= ModifierFlags.JSDocReadonly; + if (getJSDocOverrideTagNoCache(node)) flags |= ModifierFlags.JSDocOverride; + } + if (getJSDocDeferredTagNoCache(node)) flags |= ModifierFlags.JSDocDeferred; } - if (getJSDocDeprecatedTagNoCache(node)) flags |= ModifierFlags.Deprecated; + if (!isParameter(node) && getJSDocDeprecatedTagNoCache(node)) flags |= ModifierFlags.Deprecated; } return flags; @@ -7082,7 +7086,7 @@ function selectSyntacticModifierFlags(flags: ModifierFlags) { function selectEffectiveModifierFlags(flags: ModifierFlags) { return (flags & ModifierFlags.NonCacheOnlyModifiers) | - ((flags & ModifierFlags.JSDocCacheOnlyModifiers) >>> 23); // shift ModifierFlags.JSDoc* to match ModifierFlags.* + ((flags & ModifierFlags.JSDocCacheOnlyModifiers) >>> 22); // shift ModifierFlags.JSDoc* to match ModifierFlags.* } function getJSDocModifierFlagsNoCache(node: Node): ModifierFlags { diff --git a/src/compiler/utilitiesPublic.ts b/src/compiler/utilitiesPublic.ts index 1bca593edd247..25b4c838efce1 100644 --- a/src/compiler/utilitiesPublic.ts +++ b/src/compiler/utilitiesPublic.ts @@ -137,6 +137,7 @@ import { isJSDoc, isJSDocAugmentsTag, isJSDocClassTag, + isJSDocDeferredTag, isJSDocDeprecatedTag, isJSDocEnumTag, isJSDocFunctionType, @@ -183,6 +184,7 @@ import { JSDocClassTag, JSDocComment, JSDocContainer, + JSDocDeferredTag, JSDocDeprecatedTag, JSDocEnumTag, JSDocImplementsTag, @@ -1123,6 +1125,16 @@ export function getJSDocDeprecatedTagNoCache(node: Node): JSDocDeprecatedTag | u return getFirstJSDocTag(node, isJSDocDeprecatedTag, /*noCache*/ true); } +/** Gets the JSDoc deferred tag for the node if present */ +export function getJSDocDeferredTag(node: Node): JSDocDeferredTag | undefined { + return getFirstJSDocTag(node, isJSDocDeferredTag); +} + +/** @internal */ +export function getJSDocDeferredTagNoCache(node: Node): JSDocDeferredTag | undefined { + return getFirstJSDocTag(node, isJSDocDeferredTag, /*noCache*/ true); +} + /** Gets the JSDoc enum tag for the node if present */ export function getJSDocEnumTag(node: Node): JSDocEnumTag | undefined { return getFirstJSDocTag(node, isJSDocEnumTag); From 89715f299124430f5faf21eb2f7e910928f842ff Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 20 Jun 2024 09:50:31 +0200 Subject: [PATCH 17/30] Accept new API baselines --- tests/baselines/reference/api/typescript.d.ts | 91 ++++++++++--------- 1 file changed, 50 insertions(+), 41 deletions(-) diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index ed7b04076f546..73cf569b1e1fc 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -3983,32 +3983,33 @@ declare namespace ts { JSDocImplementsTag = 330, JSDocAuthorTag = 331, JSDocDeprecatedTag = 332, - JSDocClassTag = 333, - JSDocPublicTag = 334, - JSDocPrivateTag = 335, - JSDocProtectedTag = 336, - JSDocReadonlyTag = 337, - JSDocOverrideTag = 338, - JSDocCallbackTag = 339, - JSDocOverloadTag = 340, - JSDocEnumTag = 341, - JSDocParameterTag = 342, - JSDocReturnTag = 343, - JSDocThisTag = 344, - JSDocTypeTag = 345, - JSDocTemplateTag = 346, - JSDocTypedefTag = 347, - JSDocSeeTag = 348, - JSDocPropertyTag = 349, - JSDocThrowsTag = 350, - JSDocSatisfiesTag = 351, - JSDocImportTag = 352, - SyntaxList = 353, - NotEmittedStatement = 354, - PartiallyEmittedExpression = 355, - CommaListExpression = 356, - SyntheticReferenceExpression = 357, - Count = 358, + JSDocDeferredTag = 333, + JSDocClassTag = 334, + JSDocPublicTag = 335, + JSDocPrivateTag = 336, + JSDocProtectedTag = 337, + JSDocReadonlyTag = 338, + JSDocOverrideTag = 339, + JSDocCallbackTag = 340, + JSDocOverloadTag = 341, + JSDocEnumTag = 342, + JSDocParameterTag = 343, + JSDocReturnTag = 344, + JSDocThisTag = 345, + JSDocTypeTag = 346, + JSDocTemplateTag = 347, + JSDocTypedefTag = 348, + JSDocSeeTag = 349, + JSDocPropertyTag = 350, + JSDocThrowsTag = 351, + JSDocSatisfiesTag = 352, + JSDocImportTag = 353, + SyntaxList = 354, + NotEmittedStatement = 355, + PartiallyEmittedExpression = 356, + CommaListExpression = 357, + SyntheticReferenceExpression = 358, + Count = 359, FirstAssignment = 64, LastAssignment = 79, FirstCompoundAssignment = 65, @@ -4037,9 +4038,9 @@ declare namespace ts { LastStatement = 260, FirstNode = 167, FirstJSDocNode = 310, - LastJSDocNode = 352, + LastJSDocNode = 353, FirstJSDocTagNode = 328, - LastJSDocTagNode = 352, + LastJSDocTagNode = 353, } type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia; type LiteralSyntaxKind = SyntaxKind.NumericLiteral | SyntaxKind.BigIntLiteral | SyntaxKind.StringLiteral | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.RegularExpressionLiteral | SyntaxKind.NoSubstitutionTemplateLiteral; @@ -4237,17 +4238,17 @@ declare namespace ts { Protected = 4, Readonly = 8, Override = 16, - Export = 32, - Abstract = 64, - Ambient = 128, - Static = 256, - Accessor = 512, - Async = 1024, - Default = 2048, - Const = 4096, - In = 8192, - Out = 16384, - Deferred = 32768, + Deferred = 32, + Export = 64, + Abstract = 128, + Ambient = 256, + Static = 512, + Accessor = 1024, + Async = 2048, + Default = 4096, + Const = 8192, + In = 16384, + Out = 32768, Decorator = 65536, Deprecated = 131072, HasComputedJSDocModifiers = 268435456, @@ -4255,8 +4256,8 @@ declare namespace ts { AccessibilityModifier = 7, ParameterPropertyModifier = 31, NonPublicAccessibilityModifier = 6, - TypeScriptModifier = 61663, - ExportDefault = 2080, + TypeScriptModifier = 57791, + ExportDefault = 4160, All = 262143, Modifier = 196607, } @@ -5746,6 +5747,9 @@ declare namespace ts { interface JSDocDeprecatedTag extends JSDocTag { kind: SyntaxKind.JSDocDeprecatedTag; } + interface JSDocDeferredTag extends JSDocTag { + kind: SyntaxKind.JSDocDeferredTag; + } interface JSDocClassTag extends JSDocTag { readonly kind: SyntaxKind.JSDocClassTag; } @@ -7753,6 +7757,8 @@ declare namespace ts { updateJSDocUnknownTag(node: JSDocUnknownTag, tagName: Identifier, comment: string | NodeArray | undefined): JSDocUnknownTag; createJSDocDeprecatedTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeprecatedTag; updateJSDocDeprecatedTag(node: JSDocDeprecatedTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeprecatedTag; + createJSDocDeferredTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeferredTag; + updateJSDocDeferredTag(node: JSDocDeferredTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeferredTag; createJSDocOverrideTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocOverrideTag; updateJSDocOverrideTag(node: JSDocOverrideTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocOverrideTag; createJSDocThrowsTag(tagName: Identifier, typeExpression: JSDocTypeExpression | undefined, comment?: string | NodeArray): JSDocThrowsTag; @@ -8606,6 +8612,8 @@ declare namespace ts { function getJSDocOverrideTagNoCache(node: Node): JSDocOverrideTag | undefined; /** Gets the JSDoc deprecated tag for the node if present */ function getJSDocDeprecatedTag(node: Node): JSDocDeprecatedTag | undefined; + /** Gets the JSDoc deferred tag for the node if present */ + function getJSDocDeferredTag(node: Node): JSDocDeferredTag | undefined; /** Gets the JSDoc enum tag for the node if present */ function getJSDocEnumTag(node: Node): JSDocEnumTag | undefined; /** Gets the JSDoc this tag for the node if present */ @@ -9049,6 +9057,7 @@ declare namespace ts { function isJSDocOverrideTag(node: Node): node is JSDocOverrideTag; function isJSDocOverloadTag(node: Node): node is JSDocOverloadTag; function isJSDocDeprecatedTag(node: Node): node is JSDocDeprecatedTag; + function isJSDocDeferredTag(node: Node): node is JSDocDeferredTag; function isJSDocSeeTag(node: Node): node is JSDocSeeTag; function isJSDocEnumTag(node: Node): node is JSDocEnumTag; function isJSDocParameterTag(node: Node): node is JSDocParameterTag; From 329d3fc42685ecfabfb9a2463b97d0f5f9aa6fae Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 20 Jun 2024 09:50:51 +0200 Subject: [PATCH 18/30] Accept Promise print back changes --- .../asyncYieldStarContextualType.types | 16 +- tests/baselines/reference/awaitedType.types | 8 +- ...TypeAsyncFunctionReturnTypeFromUnion.types | 16 +- ...ionEmitExportAliasVisibiilityMarking.types | 8 +- ...itUsingAlternativeContainingModules1.types | 24 +- ...itUsingAlternativeContainingModules2.types | 24 +- ...destructureOfVariableSameAsShorthand.types | 16 +- .../reference/es2018ObjectAssign.types | 8 +- .../reference/esModuleInteropImportCall.types | 8 +- .../reference/genericFunctionInference1.types | 8 +- .../importCallExpression1ES2020.types | 8 +- .../importCallExpression2ES2020.types | 8 +- .../importCallExpression4ES2020.types | 8 +- .../importCallExpressionES5AMD.types | 8 +- .../importCallExpressionES5CJS.types | 8 +- .../importCallExpressionES5System.types | 8 +- .../importCallExpressionES5UMD.types | 8 +- .../importCallExpressionES6AMD.types | 8 +- .../importCallExpressionES6CJS.types | 8 +- .../importCallExpressionES6System.types | 8 +- .../importCallExpressionES6UMD.types | 8 +- .../importCallExpressionErrorInES2015.types | 8 +- .../importCallExpressionInAMD1.types | 8 +- .../importCallExpressionInAMD2.types | 8 +- .../importCallExpressionInAMD4.types | 16 +- .../importCallExpressionInCJS1.types | 8 +- .../importCallExpressionInCJS3.types | 8 +- .../importCallExpressionInCJS5.types | 16 +- .../importCallExpressionInSystem1.types | 8 +- .../importCallExpressionInSystem2.types | 8 +- .../importCallExpressionInSystem4.types | 16 +- .../importCallExpressionInUMD1.types | 8 +- .../importCallExpressionInUMD2.types | 8 +- .../importCallExpressionInUMD4.types | 16 +- ...tCallExpressionNoModuleKindSpecified.types | 8 +- ...portCallExpressionReturnPromiseOfAny.types | 8 +- ...mportCallExpressionShouldNotGetParen.types | 16 +- ...xpressionSpecifierNotStringTypeError.types | 8 +- .../baselines/reference/inferenceLimit.types | 16 +- .../instantiateContextualTypes.types | 24 +- .../reference/mappedTypesGenericTuples2.types | 8 +- .../modularizeLibrary_Dom.asynciterable.types | 8 +- ...eLibrary_NoErrorDuplicateLibOptions1.types | 8 +- ...eLibrary_NoErrorDuplicateLibOptions2.types | 8 +- ...dularizeLibrary_TargetES5UsingES6Lib.types | 8 +- ...dularizeLibrary_Worker.asynciterable.types | 8 +- .../moduleResolutionWithoutExtension5.types | 8 +- .../moduleResolutionWithoutExtension8.types | 8 +- .../optionalFunctionArgAssignability.types | 4 +- .../reference/privateNameMethodAsync.types | 8 +- .../reference/promisePermutations.errors.txt | 4 +- .../reference/promisePermutations.types | 448 ++++---- .../reference/promisePermutations2.errors.txt | 4 +- .../reference/promisePermutations2.types | 436 ++++---- .../reference/promisePermutations3.errors.txt | 4 +- .../reference/promisePermutations3.types | 448 ++++---- tests/baselines/reference/promiseTest.types | 16 +- tests/baselines/reference/promiseType.types | 976 +++++++++--------- .../reference/promiseTypeStrictNull.types | 976 +++++++++--------- .../reference/promiseVoidErrorCallback.types | 16 +- tests/baselines/reference/promises.types | 8 +- .../reference/promisesWithConstraints.types | 4 +- .../reference/specializationError.types | 4 +- ...eticDefaultExportsWithDynamicImports.types | 8 +- .../reference/truthinessPromiseCoercion.types | 16 +- .../unionAndIntersectionInference1.types | 8 +- .../reference/unionOfClassCalls.types | 8 +- .../reference/usePromiseFinally.types | 8 +- 68 files changed, 1954 insertions(+), 1954 deletions(-) diff --git a/tests/baselines/reference/asyncYieldStarContextualType.types b/tests/baselines/reference/asyncYieldStarContextualType.types index 55377518eb3e0..e3d8c69a7eab8 100644 --- a/tests/baselines/reference/asyncYieldStarContextualType.types +++ b/tests/baselines/reference/asyncYieldStarContextualType.types @@ -65,12 +65,12 @@ async function* f(): AsyncGenerator<"NOT_FOUND_AUTHOR" | "NOT_FOUND_BOOK", BookW > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >authorPromise.then(mapper) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->authorPromise.then : , TResult2 = never>(onfulfilled?: (value: Result) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>authorPromise.then : , TResult2 = never>(deferred onfulfilled?: (value: Result) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >authorPromise : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : , TResult2 = never>(onfulfilled?: (value: Result) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : , TResult2 = never>(deferred onfulfilled?: (value: Result) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >mapper : (result: Result) => Result > : ^ ^^ ^^ ^^^^^ @@ -86,12 +86,12 @@ async function* f(): AsyncGenerator<"NOT_FOUND_AUTHOR" | "NOT_FOUND_BOOK", BookW > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >authorPromise.then(mapper) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->authorPromise.then : , TResult2 = never>(onfulfilled?: (value: Result) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>authorPromise.then : , TResult2 = never>(deferred onfulfilled?: (value: Result) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >authorPromise : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : , TResult2 = never>(onfulfilled?: (value: Result) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : , TResult2 = never>(deferred onfulfilled?: (value: Result) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >mapper : (result: Result) => Result > : ^ ^^ ^^ ^^^^^ diff --git a/tests/baselines/reference/awaitedType.types b/tests/baselines/reference/awaitedType.types index dbc8add717e93..1c1e56d051f9c 100644 --- a/tests/baselines/reference/awaitedType.types +++ b/tests/baselines/reference/awaitedType.types @@ -801,8 +801,8 @@ async function mainFindMany() { Promise.all(promises).then((results) => { >Promise.all(promises).then((results) => { const first = results[0] const second = results[1] // error }) : Promise > : ^^^^^^^^^^^^^ ->Promise.all(promises).then : (onfulfilled?: (value: [number]) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>Promise.all(promises).then : (deferred onfulfilled?: (value: [number]) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >Promise.all(promises) : Promise<[number]> > : ^^^^^^^^^^^^^^^^^ >Promise.all : { (values: Iterable>): Promise[]>; (values: T): Promise<{ -readonly [P in keyof T]: Awaited; }>; } @@ -813,8 +813,8 @@ async function mainFindMany() { > : ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^ ^^^ >promises : readonly [Promise] > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: [number]) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: [number]) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >(results) => { const first = results[0] const second = results[1] // error } : (results: [number]) => void > : ^ ^^^^^^^^^^^^^^^^^^^ >results : [number] diff --git a/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnTypeFromUnion.types b/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnTypeFromUnion.types index 434665fea85fb..8d30e5ae7587e 100644 --- a/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnTypeFromUnion.types +++ b/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnTypeFromUnion.types @@ -119,14 +119,14 @@ const cb1: LoadCallback = async () => load().then(m => m); > : ^^^^^^^^^^^^^^^^^^^^^^ >load().then(m => m) : Promise > : ^^^^^^^^^^^^^^^^ ->load().then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>load().then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >load() : Promise > : ^^^^^^^^^^^^^^^^ >load : () => Promise > : ^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >m => m : (m: boolean) => boolean > : ^ ^^^^^^^^^^^^^^^^^^^^^ >m : boolean @@ -151,14 +151,14 @@ const cb3: LoadCallback = () => load().then(m => m); > : ^^^^^^^^^^^^^^^^^^^^^^ >load().then(m => m) : Promise > : ^^^^^^^^^^^^^^^^ ->load().then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>load().then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >load() : Promise > : ^^^^^^^^^^^^^^^^ >load : () => Promise > : ^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >m => m : (m: boolean) => boolean > : ^ ^^^^^^^^^^^^^^^^^^^^^ >m : boolean diff --git a/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types b/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types index d66f2da8943ea..66c3da3411e06 100644 --- a/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types +++ b/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types @@ -46,14 +46,14 @@ export let lazyCard = () => import('./Card').then(a => a.default); > : ^^^^^^^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >import('./Card').then(a => a.default) : Promise<(suit: import("Types").Suit, rank: import("Types").Rank) => { suit: import("Types").Suit; rank: import("Types").Rank; }> > : ^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->import('./Card').then : (onfulfilled?: (value: typeof import("Card")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>import('./Card').then : (deferred onfulfilled?: (value: typeof import("Card")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >import('./Card') : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >'./Card' : "./Card" > : ^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("Card")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("Card")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >a => a.default : (a: typeof import("Card")) => (suit: import("Types").Suit, rank: import("Types").Rank) => { suit: import("Types").Suit; rank: import("Types").Rank; } > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >a : typeof import("Card") diff --git a/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules1.types b/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules1.types index 8f899d31613c0..fad51aee2cbfa 100644 --- a/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules1.types +++ b/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules1.types @@ -431,16 +431,16 @@ const testApi = { return fetch(baseUrl + 'entries') >fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch((err) => console.log(err)) : Promise > : ^^^^^^^^^^^^ ->fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ +>fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ >fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) : Promise > : ^^^^^^^^^^^^ ->fetch(baseUrl + 'entries') .then((res) => res.json()) .then : (onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>fetch(baseUrl + 'entries') .then((res) => res.json()) .then : (deferred onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >fetch(baseUrl + 'entries') .then((res) => res.json()) : Promise > : ^^^^^^^^^^^^ ->fetch(baseUrl + 'entries') .then : (onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>fetch(baseUrl + 'entries') .then : (deferred onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >fetch(baseUrl + 'entries') : Promise > : ^^^^^^^^^^^^^^^^^ >fetch : (input: RequestInfo | URL, init?: RequestInit) => Promise @@ -453,8 +453,8 @@ const testApi = { > : ^^^^^^^^^ .then((res) => res.json()) ->then : (onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >(res) => res.json() : (res: Response) => Promise > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >res : Response @@ -469,8 +469,8 @@ const testApi = { > : ^^^^^^ .then((data) => data.entries) ->then : (onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >(data) => data.entries : (data: any) => any > : ^ ^^^^^^^^^^^^^ >data : any @@ -481,8 +481,8 @@ const testApi = { > : ^^^ .catch((err) => console.log(err)) ->catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ +>catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ >(err) => console.log(err) : (err: any) => void > : ^ ^^^^^^^^^^^^^^ >err : any diff --git a/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules2.types b/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules2.types index 9db2d2654d9e2..e7707178757a9 100644 --- a/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules2.types +++ b/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules2.types @@ -439,16 +439,16 @@ const testApi = { return fetch(baseUrl + 'entries') >fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch((err) => console.log(err)) : Promise > : ^^^^^^^^^^^^ ->fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ +>fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ >fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) : Promise > : ^^^^^^^^^^^^ ->fetch(baseUrl + 'entries') .then((res) => res.json()) .then : (onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>fetch(baseUrl + 'entries') .then((res) => res.json()) .then : (deferred onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >fetch(baseUrl + 'entries') .then((res) => res.json()) : Promise > : ^^^^^^^^^^^^ ->fetch(baseUrl + 'entries') .then : (onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>fetch(baseUrl + 'entries') .then : (deferred onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >fetch(baseUrl + 'entries') : Promise > : ^^^^^^^^^^^^^^^^^ >fetch : (input: RequestInfo | URL, init?: RequestInit) => Promise @@ -461,8 +461,8 @@ const testApi = { > : ^^^^^^^^^ .then((res) => res.json()) ->then : (onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >(res) => res.json() : (res: Response) => Promise > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >res : Response @@ -477,8 +477,8 @@ const testApi = { > : ^^^^^^ .then((data) => data.entries) ->then : (onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >(data) => data.entries : (data: any) => any > : ^ ^^^^^^^^^^^^^ >data : any @@ -489,8 +489,8 @@ const testApi = { > : ^^^ .catch((err) => console.log(err)) ->catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ +>catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ >(err) => console.log(err) : (err: any) => void > : ^ ^^^^^^^^^^^^^^ >err : any diff --git a/tests/baselines/reference/destructureOfVariableSameAsShorthand.types b/tests/baselines/reference/destructureOfVariableSameAsShorthand.types index 15a04e9267be2..cc84dcd4eb494 100644 --- a/tests/baselines/reference/destructureOfVariableSameAsShorthand.types +++ b/tests/baselines/reference/destructureOfVariableSameAsShorthand.types @@ -20,14 +20,14 @@ async function main() { get().then((response) => { >get().then((response) => { // body is never const body = response.data; }) : Promise > : ^^^^^^^^^^^^^ ->get().then : , TResult2 = never>(onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>get().then : , TResult2 = never>(deferred onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >get() : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >get : >() => Promise > : ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : , TResult2 = never>(onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : , TResult2 = never>(deferred onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >(response) => { // body is never const body = response.data; } : (response: AxiosResponse) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >response : AxiosResponse @@ -48,14 +48,14 @@ async function main() { get().then(({ data }) => { >get().then(({ data }) => { // data is never }) : Promise > : ^^^^^^^^^^^^^ ->get().then : , TResult2 = never>(onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>get().then : , TResult2 = never>(deferred onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >get() : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >get : >() => Promise > : ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : , TResult2 = never>(onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : , TResult2 = never>(deferred onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >({ data }) => { // data is never } : ({ data }: AxiosResponse) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >data : never diff --git a/tests/baselines/reference/es2018ObjectAssign.types b/tests/baselines/reference/es2018ObjectAssign.types index 3ae8df0b5c585..1044b7b6a5337 100644 --- a/tests/baselines/reference/es2018ObjectAssign.types +++ b/tests/baselines/reference/es2018ObjectAssign.types @@ -28,10 +28,10 @@ declare const p: Promise; p.finally(); >p.finally() : Promise > : ^^^^^^^^^^^^^^^ ->p.finally : (onfinally?: () => void) => Promise -> : ^ ^^^^^^^^^ ^^^^^ ^^^^^^ +>p.finally : (deferred onfinally?: () => void) => Promise +> : ^ ^ ^^^^^^^^^ ^^^^^ ^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^ ->finally : (onfinally?: () => void) => Promise -> : ^ ^^^^^^^^^ ^^^^^ ^^^^^^ +>finally : (deferred onfinally?: () => void) => Promise +> : ^ ^ ^^^^^^^^^ ^^^^^ ^^^^^^ diff --git a/tests/baselines/reference/esModuleInteropImportCall.types b/tests/baselines/reference/esModuleInteropImportCall.types index 85bcc4c7d1e81..76b0a494aad1d 100644 --- a/tests/baselines/reference/esModuleInteropImportCall.types +++ b/tests/baselines/reference/esModuleInteropImportCall.types @@ -14,14 +14,14 @@ export = foo; import("./foo").then(f => { >import("./foo").then(f => { f.default;}) : Promise > : ^^^^^^^^^^^^^ ->import("./foo").then : void; }, TResult2 = never>(onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>import("./foo").then : void; }, TResult2 = never>(deferred onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >import("./foo") : Promise<{ default: () => void; }> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ >"./foo" : "./foo" > : ^^^^^^^ ->then : void; }, TResult2 = never>(onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : void; }, TResult2 = never>(deferred onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >f => { f.default;} : (f: { default: () => void; }) => void > : ^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ >f : { default: () => void; } diff --git a/tests/baselines/reference/genericFunctionInference1.types b/tests/baselines/reference/genericFunctionInference1.types index 35127cce611af..440771ec8f2e2 100644 --- a/tests/baselines/reference/genericFunctionInference1.types +++ b/tests/baselines/reference/genericFunctionInference1.types @@ -1421,12 +1421,12 @@ const promise = Promise.resolve(1); promise.then( >promise.then( pipe( x => x + 1, x => x * 2, ),) : Promise > : ^^^^^^^^^^^^^^^ ->promise.then : (onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>promise.then : (deferred onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >promise : Promise > : ^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ pipe( >pipe( x => x + 1, x => x * 2, ) : (x: number) => number diff --git a/tests/baselines/reference/importCallExpression1ES2020.types b/tests/baselines/reference/importCallExpression1ES2020.types index 7e7f771fa9eba..4ca7c3bea7f4f 100644 --- a/tests/baselines/reference/importCallExpression1ES2020.types +++ b/tests/baselines/reference/importCallExpression1ES2020.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpression2ES2020.types b/tests/baselines/reference/importCallExpression2ES2020.types index 75ef1139e1af5..c24acdbeb1d23 100644 --- a/tests/baselines/reference/importCallExpression2ES2020.types +++ b/tests/baselines/reference/importCallExpression2ES2020.types @@ -22,12 +22,12 @@ function foo(x: Promise) { x.then(value => { >x.then(value => { let b = new value.B(); b.print(); }) : Promise > : ^^^^^^^^^^^^^ ->x.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>x.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >x : Promise > : ^^^^^^^^^^^^ ->then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >value => { let b = new value.B(); b.print(); } : (value: any) => void > : ^ ^^^^^^^^^^^^^^ >value : any diff --git a/tests/baselines/reference/importCallExpression4ES2020.types b/tests/baselines/reference/importCallExpression4ES2020.types index 1625b91206eb3..366b14047d4e6 100644 --- a/tests/baselines/reference/importCallExpression4ES2020.types +++ b/tests/baselines/reference/importCallExpression4ES2020.types @@ -56,16 +56,16 @@ class C { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES5AMD.types b/tests/baselines/reference/importCallExpressionES5AMD.types index 8e24cd582f7cb..7d5289400494e 100644 --- a/tests/baselines/reference/importCallExpressionES5AMD.types +++ b/tests/baselines/reference/importCallExpressionES5AMD.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES5CJS.types b/tests/baselines/reference/importCallExpressionES5CJS.types index 501c43763a188..5fec33fe6241c 100644 --- a/tests/baselines/reference/importCallExpressionES5CJS.types +++ b/tests/baselines/reference/importCallExpressionES5CJS.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES5System.types b/tests/baselines/reference/importCallExpressionES5System.types index 8c63aeff3a55f..e67967b4773b9 100644 --- a/tests/baselines/reference/importCallExpressionES5System.types +++ b/tests/baselines/reference/importCallExpressionES5System.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES5UMD.types b/tests/baselines/reference/importCallExpressionES5UMD.types index 113dcde37851d..19dd795c4893b 100644 --- a/tests/baselines/reference/importCallExpressionES5UMD.types +++ b/tests/baselines/reference/importCallExpressionES5UMD.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES6AMD.types b/tests/baselines/reference/importCallExpressionES6AMD.types index 93766fb50580f..404347c93776d 100644 --- a/tests/baselines/reference/importCallExpressionES6AMD.types +++ b/tests/baselines/reference/importCallExpressionES6AMD.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES6CJS.types b/tests/baselines/reference/importCallExpressionES6CJS.types index 1e644e40682ef..1a9ac226a3351 100644 --- a/tests/baselines/reference/importCallExpressionES6CJS.types +++ b/tests/baselines/reference/importCallExpressionES6CJS.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES6System.types b/tests/baselines/reference/importCallExpressionES6System.types index c300a7caed931..640972b5c0779 100644 --- a/tests/baselines/reference/importCallExpressionES6System.types +++ b/tests/baselines/reference/importCallExpressionES6System.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES6UMD.types b/tests/baselines/reference/importCallExpressionES6UMD.types index cda6980518b1c..520b5f27ad873 100644 --- a/tests/baselines/reference/importCallExpressionES6UMD.types +++ b/tests/baselines/reference/importCallExpressionES6UMD.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionErrorInES2015.types b/tests/baselines/reference/importCallExpressionErrorInES2015.types index 8203a0a0657de..de48f59592a13 100644 --- a/tests/baselines/reference/importCallExpressionErrorInES2015.types +++ b/tests/baselines/reference/importCallExpressionErrorInES2015.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInAMD1.types b/tests/baselines/reference/importCallExpressionInAMD1.types index 0bd12b6af9f2d..18f3bafb193dc 100644 --- a/tests/baselines/reference/importCallExpressionInAMD1.types +++ b/tests/baselines/reference/importCallExpressionInAMD1.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInAMD2.types b/tests/baselines/reference/importCallExpressionInAMD2.types index 24545d8db1bd5..9c755b54b6285 100644 --- a/tests/baselines/reference/importCallExpressionInAMD2.types +++ b/tests/baselines/reference/importCallExpressionInAMD2.types @@ -23,12 +23,12 @@ function foo(x: Promise) { x.then(value => { >x.then(value => { let b = new value.B(); b.print(); }) : Promise > : ^^^^^^^^^^^^^ ->x.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>x.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >x : Promise > : ^^^^^^^^^^^^ ->then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >value => { let b = new value.B(); b.print(); } : (value: any) => void > : ^ ^^^^^^^^^^^^^^ >value : any diff --git a/tests/baselines/reference/importCallExpressionInAMD4.types b/tests/baselines/reference/importCallExpressionInAMD4.types index 868eb740fcdcb..f2a4b7f1acff3 100644 --- a/tests/baselines/reference/importCallExpressionInAMD4.types +++ b/tests/baselines/reference/importCallExpressionInAMD4.types @@ -56,16 +56,16 @@ class C { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") @@ -158,16 +158,16 @@ export class D { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInCJS1.types b/tests/baselines/reference/importCallExpressionInCJS1.types index ec1c939c0418a..7764437f87400 100644 --- a/tests/baselines/reference/importCallExpressionInCJS1.types +++ b/tests/baselines/reference/importCallExpressionInCJS1.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInCJS3.types b/tests/baselines/reference/importCallExpressionInCJS3.types index 8ec0be061f1b7..93230c55a6d5b 100644 --- a/tests/baselines/reference/importCallExpressionInCJS3.types +++ b/tests/baselines/reference/importCallExpressionInCJS3.types @@ -23,12 +23,12 @@ function foo(x: Promise) { x.then(value => { >x.then(value => { let b = new value.B(); b.print(); }) : Promise > : ^^^^^^^^^^^^^ ->x.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>x.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >x : Promise > : ^^^^^^^^^^^^ ->then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >value => { let b = new value.B(); b.print(); } : (value: any) => void > : ^ ^^^^^^^^^^^^^^ >value : any diff --git a/tests/baselines/reference/importCallExpressionInCJS5.types b/tests/baselines/reference/importCallExpressionInCJS5.types index 02345e1540084..40dcc0632a0a1 100644 --- a/tests/baselines/reference/importCallExpressionInCJS5.types +++ b/tests/baselines/reference/importCallExpressionInCJS5.types @@ -56,16 +56,16 @@ class C { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") @@ -158,16 +158,16 @@ export class D { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInSystem1.types b/tests/baselines/reference/importCallExpressionInSystem1.types index 419e45ed1231a..ce3a5d5e89393 100644 --- a/tests/baselines/reference/importCallExpressionInSystem1.types +++ b/tests/baselines/reference/importCallExpressionInSystem1.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInSystem2.types b/tests/baselines/reference/importCallExpressionInSystem2.types index 57a802e9b8602..1389432e524f3 100644 --- a/tests/baselines/reference/importCallExpressionInSystem2.types +++ b/tests/baselines/reference/importCallExpressionInSystem2.types @@ -23,12 +23,12 @@ function foo(x: Promise) { x.then(value => { >x.then(value => { let b = new value.B(); b.print(); }) : Promise > : ^^^^^^^^^^^^^ ->x.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>x.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >x : Promise > : ^^^^^^^^^^^^ ->then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >value => { let b = new value.B(); b.print(); } : (value: any) => void > : ^ ^^^^^^^^^^^^^^ >value : any diff --git a/tests/baselines/reference/importCallExpressionInSystem4.types b/tests/baselines/reference/importCallExpressionInSystem4.types index 775a95336e576..abb046d51dcdd 100644 --- a/tests/baselines/reference/importCallExpressionInSystem4.types +++ b/tests/baselines/reference/importCallExpressionInSystem4.types @@ -56,16 +56,16 @@ class C { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") @@ -158,16 +158,16 @@ export class D { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInUMD1.types b/tests/baselines/reference/importCallExpressionInUMD1.types index b406128931f54..b620815d5e571 100644 --- a/tests/baselines/reference/importCallExpressionInUMD1.types +++ b/tests/baselines/reference/importCallExpressionInUMD1.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInUMD2.types b/tests/baselines/reference/importCallExpressionInUMD2.types index 463bd298d3cb9..88806cc354e47 100644 --- a/tests/baselines/reference/importCallExpressionInUMD2.types +++ b/tests/baselines/reference/importCallExpressionInUMD2.types @@ -23,12 +23,12 @@ function foo(x: Promise) { x.then(value => { >x.then(value => { let b = new value.B(); b.print(); }) : Promise > : ^^^^^^^^^^^^^ ->x.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>x.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >x : Promise > : ^^^^^^^^^^^^ ->then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >value => { let b = new value.B(); b.print(); } : (value: any) => void > : ^ ^^^^^^^^^^^^^^ >value : any diff --git a/tests/baselines/reference/importCallExpressionInUMD4.types b/tests/baselines/reference/importCallExpressionInUMD4.types index c3f06ea8005b7..700bdf4227c4e 100644 --- a/tests/baselines/reference/importCallExpressionInUMD4.types +++ b/tests/baselines/reference/importCallExpressionInUMD4.types @@ -56,16 +56,16 @@ class C { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") @@ -158,16 +158,16 @@ export class D { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types index 0cfec665db959..b3cb53ae3ec10 100644 --- a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types +++ b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types @@ -57,16 +57,16 @@ class C { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types index d568f760841df..1a14e7d24099f 100644 --- a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types +++ b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types @@ -109,12 +109,12 @@ const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise { >p1.then(zero => { return zero.foo(); // ok, zero is any}) : Promise > : ^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^ ->then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo(); // ok, zero is any} : (zero: any) => any > : ^ ^^^^^^^^^^^^^ >zero : any diff --git a/tests/baselines/reference/importCallExpressionShouldNotGetParen.types b/tests/baselines/reference/importCallExpressionShouldNotGetParen.types index 9b6e655b78586..41e4b42700c3c 100644 --- a/tests/baselines/reference/importCallExpressionShouldNotGetParen.types +++ b/tests/baselines/reference/importCallExpressionShouldNotGetParen.types @@ -10,16 +10,16 @@ const localeName = "zh-CN"; import(`./locales/${localeName}.js`).then(bar => { >import(`./locales/${localeName}.js`).then(bar => { let x = bar;}) : Promise > : ^^^^^^^^^^^^^ ->import(`./locales/${localeName}.js`).then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>import(`./locales/${localeName}.js`).then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >import(`./locales/${localeName}.js`) : Promise > : ^^^^^^^^^^^^ >`./locales/${localeName}.js` : "./locales/zh-CN.js" > : ^^^^^^^^^^^^^^^^^^^^ >localeName : "zh-CN" > : ^^^^^^^ ->then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >bar => { let x = bar;} : (bar: any) => void > : ^ ^^^^^^^^^^^^^^ >bar : any @@ -33,8 +33,8 @@ import(`./locales/${localeName}.js`).then(bar => { import("./locales/" + localeName + ".js").then(bar => { >import("./locales/" + localeName + ".js").then(bar => { let x = bar;}) : Promise > : ^^^^^^^^^^^^^ ->import("./locales/" + localeName + ".js").then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>import("./locales/" + localeName + ".js").then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >import("./locales/" + localeName + ".js") : Promise > : ^^^^^^^^^^^^ >"./locales/" + localeName + ".js" : string @@ -47,8 +47,8 @@ import("./locales/" + localeName + ".js").then(bar => { > : ^^^^^^^ >".js" : ".js" > : ^^^^^ ->then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >bar => { let x = bar;} : (bar: any) => void > : ^ ^^^^^^^^^^^^^^ >bar : any diff --git a/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types index 83336624b178f..e788220315094 100644 --- a/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types +++ b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types @@ -47,12 +47,12 @@ const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") p1.then(zero => { >p1.then(zero => { return zero.foo(); // ok, zero is any}) : Promise > : ^^^^^^^^^^^^ ->p1.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p1.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^ ->then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >zero => { return zero.foo(); // ok, zero is any} : (zero: any) => any > : ^ ^^^^^^^^^^^^^ >zero : any diff --git a/tests/baselines/reference/inferenceLimit.types b/tests/baselines/reference/inferenceLimit.types index 5e462a6227fa0..f0f8e50c09885 100644 --- a/tests/baselines/reference/inferenceLimit.types +++ b/tests/baselines/reference/inferenceLimit.types @@ -67,8 +67,8 @@ export class BrokenClass { this.doStuff(order.id) >this.doStuff(order.id) .then((items) => { order.items = items; resolve(order); }) : Promise > : ^^^^^^^^^^^^^ ->this.doStuff(order.id) .then : (onfulfilled?: (value: void) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>this.doStuff(order.id) .then : (deferred onfulfilled?: (value: void) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >this.doStuff(order.id) : Promise > : ^^^^^^^^^^^^^ >this.doStuff : (id: number) => Promise @@ -84,8 +84,8 @@ export class BrokenClass { > : ^^^ .then((items) => { ->then : (onfulfilled?: (value: void) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: void) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >(items) => { order.items = items; resolve(order); } : (items: void) => void > : ^ ^^^^^^^^^^^^^^^ >items : void @@ -116,8 +116,8 @@ export class BrokenClass { return Promise.all(result.map(populateItems)) >Promise.all(result.map(populateItems)) .then((orders: Array) => { resolve(orders); }) : Promise > : ^^^^^^^^^^^^^ ->Promise.all(result.map(populateItems)) .then : (onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>Promise.all(result.map(populateItems)) .then : (deferred onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >Promise.all(result.map(populateItems)) : Promise > : ^^^^^^^^^^^^^^^^^^ >Promise.all : { (values: Iterable>): Promise[]>; (values: T): Promise<{ -readonly [P in keyof T]: Awaited; }>; } @@ -138,8 +138,8 @@ export class BrokenClass { > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ .then((orders: Array) => { ->then : (onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >(orders: Array) => { resolve(orders); } : (orders: Array) => void > : ^ ^^ ^^^^^^^^^ >orders : MyModule.MyModel[] diff --git a/tests/baselines/reference/instantiateContextualTypes.types b/tests/baselines/reference/instantiateContextualTypes.types index 775a7730090ab..e56bb66d4b665 100644 --- a/tests/baselines/reference/instantiateContextualTypes.types +++ b/tests/baselines/reference/instantiateContextualTypes.types @@ -493,8 +493,8 @@ class Interesting { return Promise.resolve().then(() => { >Promise.resolve().then(() => { if (1 < 2) { return 'SOMETHING'; } return 'ELSE'; }) : Promise<"SOMETHING" | "ELSE"> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->Promise.resolve().then : (onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>Promise.resolve().then : (deferred onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >Promise.resolve() : Promise > : ^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -503,8 +503,8 @@ class Interesting { > : ^^^^^^^^^^^^^^^^^^ >resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } > : ^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ->then : (onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => { if (1 < 2) { return 'SOMETHING'; } return 'ELSE'; } : () => "SOMETHING" | "ELSE" > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -535,8 +535,8 @@ class Interesting { return Promise.resolve().then(() => { >Promise.resolve().then(() => { return 'ELSE'; }) : Promise<"SOMETHING" | "ELSE"> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->Promise.resolve().then : (onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>Promise.resolve().then : (deferred onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >Promise.resolve() : Promise > : ^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -545,8 +545,8 @@ class Interesting { > : ^^^^^^^^^^^^^^^^^^ >resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } > : ^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ->then : (onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => { return 'ELSE'; } : () => "ELSE" > : ^^^^^^^^^^^^ @@ -565,8 +565,8 @@ class Interesting { return Promise.resolve().then(() => { >Promise.resolve().then(() => { if (1 < 2) { return 'SOMETHING'; } return 'SOMETHING'; }) : Promise<"SOMETHING" | "ELSE"> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->Promise.resolve().then : (onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>Promise.resolve().then : (deferred onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >Promise.resolve() : Promise > : ^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -575,8 +575,8 @@ class Interesting { > : ^^^^^^^^^^^^^^^^^^ >resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } > : ^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ->then : (onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => { if (1 < 2) { return 'SOMETHING'; } return 'SOMETHING'; } : () => "SOMETHING" > : ^^^^^^^^^^^^^^^^^ diff --git a/tests/baselines/reference/mappedTypesGenericTuples2.types b/tests/baselines/reference/mappedTypesGenericTuples2.types index 26e5366029f05..a3642cd1bc406 100644 --- a/tests/baselines/reference/mappedTypesGenericTuples2.types +++ b/tests/baselines/reference/mappedTypesGenericTuples2.types @@ -10,8 +10,8 @@ declare function getT(): T; Promise.all([getT(), ...getT()]).then((result) => { >Promise.all([getT(), ...getT()]).then((result) => { const head = result[0]; // string const tail = result.slice(1); // any[] tail satisfies string[]; // ok}) : Promise > : ^^^^^^^^^^^^^ ->Promise.all([getT(), ...getT()]).then : (onfulfilled?: ((value: [string, ...any[]]) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>Promise.all([getT(), ...getT()]).then : (deferred onfulfilled?: ((value: [string, ...any[]]) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >Promise.all([getT(), ...getT()]) : Promise<[string, ...any[]]> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Promise.all : { (values: Iterable>): Promise[]>; (values: T): Promise<{ -readonly [P in keyof T]: Awaited; }>; } @@ -30,8 +30,8 @@ Promise.all([getT(), ...getT()]).then((result) => { >getT() : any >getT : () => T > : ^ ^^^^^^^ ->then : (onfulfilled?: ((value: [string, ...any[]]) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: [string, ...any[]]) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >(result) => { const head = result[0]; // string const tail = result.slice(1); // any[] tail satisfies string[]; // ok} : (result: [string, ...any[]]) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >result : [string, ...any[]] diff --git a/tests/baselines/reference/modularizeLibrary_Dom.asynciterable.types b/tests/baselines/reference/modularizeLibrary_Dom.asynciterable.types index 9d1476e69c22f..fb49024ce6c22 100644 --- a/tests/baselines/reference/modularizeLibrary_Dom.asynciterable.types +++ b/tests/baselines/reference/modularizeLibrary_Dom.asynciterable.types @@ -4,8 +4,8 @@ navigator.storage.getDirectory().then(async directory => { >navigator.storage.getDirectory().then(async directory => { for await (const [key, handle] of directory) { handle.kind; }}) : Promise > : ^^^^^^^^^^^^^ ->navigator.storage.getDirectory().then : (onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>navigator.storage.getDirectory().then : (deferred onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >navigator.storage.getDirectory() : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >navigator.storage.getDirectory : () => Promise @@ -18,8 +18,8 @@ navigator.storage.getDirectory().then(async directory => { > : ^^^^^^^^^^^^^^ >getDirectory : () => Promise > : ^^^^^^ ->then : (onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >async directory => { for await (const [key, handle] of directory) { handle.kind; }} : (directory: FileSystemDirectoryHandle) => Promise > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >directory : FileSystemDirectoryHandle diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types index 2075637dfce8d..15fe64af74098 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types @@ -225,14 +225,14 @@ declare var console: any; out().then(() => { >out().then(() => { console.log("Yea!");}) : Promise > : ^^^^^^^^^^^^^ ->out().then : (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>out().then : (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >out() : Promise > : ^^^^^^^^^^^^^^^^ >out : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => { console.log("Yea!");} : () => void > : ^^^^^^^^^^ diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types index f07eee75a879e..baac075288dff 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types @@ -225,14 +225,14 @@ declare var console: any; out().then(() => { >out().then(() => { console.log("Yea!");}) : Promise > : ^^^^^^^^^^^^^ ->out().then : (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>out().then : (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >out() : Promise > : ^^^^^^^^^^^^^^^^ >out : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => { console.log("Yea!");} : () => void > : ^^^^^^^^^^ diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types index 51aa526440d80..73692f90575b8 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types +++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types @@ -225,14 +225,14 @@ declare var console: any; out().then(() => { >out().then(() => { console.log("Yea!");}) : Promise > : ^^^^^^^^^^^^^ ->out().then : (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>out().then : (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >out() : Promise > : ^^^^^^^^^^^^^^^^ >out : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => { console.log("Yea!");} : () => void > : ^^^^^^^^^^ diff --git a/tests/baselines/reference/modularizeLibrary_Worker.asynciterable.types b/tests/baselines/reference/modularizeLibrary_Worker.asynciterable.types index 6189b4ae3e7ee..9d5920a1a71c8 100644 --- a/tests/baselines/reference/modularizeLibrary_Worker.asynciterable.types +++ b/tests/baselines/reference/modularizeLibrary_Worker.asynciterable.types @@ -4,8 +4,8 @@ navigator.storage.getDirectory().then(async directory => { >navigator.storage.getDirectory().then(async directory => { for await (const [key, handle] of directory) { handle.kind; }}) : Promise > : ^^^^^^^^^^^^^ ->navigator.storage.getDirectory().then : (onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>navigator.storage.getDirectory().then : (deferred onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >navigator.storage.getDirectory() : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >navigator.storage.getDirectory : () => Promise @@ -18,8 +18,8 @@ navigator.storage.getDirectory().then(async directory => { > : ^^^^^^^^^^^^^^ >getDirectory : () => Promise > : ^^^^^^ ->then : (onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >async directory => { for await (const [key, handle] of directory) { handle.kind; }} : (directory: FileSystemDirectoryHandle) => Promise > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >directory : FileSystemDirectoryHandle diff --git a/tests/baselines/reference/moduleResolutionWithoutExtension5.types b/tests/baselines/reference/moduleResolutionWithoutExtension5.types index 7898309ec6b04..afb1b092f6e7f 100644 --- a/tests/baselines/reference/moduleResolutionWithoutExtension5.types +++ b/tests/baselines/reference/moduleResolutionWithoutExtension5.types @@ -5,14 +5,14 @@ import("./foo").then(x => x); // should error, ask for extension >import("./foo").then(x => x) : Promise > : ^^^^^^^^^^^^ ->import("./foo").then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>import("./foo").then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >import("./foo") : Promise > : ^^^^^^^^^^^^ >"./foo" : "./foo" > : ^^^^^^^ ->then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >x => x : (x: any) => any > : ^ ^^^^^^^^^^^^^ >x : any diff --git a/tests/baselines/reference/moduleResolutionWithoutExtension8.types b/tests/baselines/reference/moduleResolutionWithoutExtension8.types index 5361c56bad849..b1596e76b3f79 100644 --- a/tests/baselines/reference/moduleResolutionWithoutExtension8.types +++ b/tests/baselines/reference/moduleResolutionWithoutExtension8.types @@ -5,14 +5,14 @@ import("./foo").then(x => x); // should error, ask for extension >import("./foo").then(x => x) : Promise > : ^^^^^^^^^^^^ ->import("./foo").then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>import("./foo").then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >import("./foo") : Promise > : ^^^^^^^^^^^^ >"./foo" : "./foo" > : ^^^^^^^ ->then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >x => x : (x: any) => any > : ^ ^^^^^^^^^^^^^ >x : any diff --git a/tests/baselines/reference/optionalFunctionArgAssignability.types b/tests/baselines/reference/optionalFunctionArgAssignability.types index c7190317bdae9..b667063d259aa 100644 --- a/tests/baselines/reference/optionalFunctionArgAssignability.types +++ b/tests/baselines/reference/optionalFunctionArgAssignability.types @@ -3,8 +3,8 @@ === optionalFunctionArgAssignability.ts === interface Promise { then(onFulfill?: (value: T) => U, onReject?: (reason: any) => U): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (onFulfill?: (value: T) => U, onReject?: (reason: any) => U): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (onFulfill?: (value: T) => U, onReject?: (reason: any) => U): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >onFulfill : (value: T) => U > : ^ ^^ ^^^^^ >value : T diff --git a/tests/baselines/reference/privateNameMethodAsync.types b/tests/baselines/reference/privateNameMethodAsync.types index f5a0abeb3a06e..327e1d1ed572c 100644 --- a/tests/baselines/reference/privateNameMethodAsync.types +++ b/tests/baselines/reference/privateNameMethodAsync.types @@ -128,8 +128,8 @@ const C = class { new C().foo().then(console.log); >new C().foo().then(console.log) : Promise > : ^^^^^^^^^^^^^ ->new C().foo().then : (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>new C().foo().then : (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >new C().foo() : Promise > : ^^^^^^^^^^^^^^^ >new C().foo : () => Promise @@ -140,8 +140,8 @@ new C().foo().then(console.log); > : ^^^^^^^^ >foo : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >console.log : (...data: any[]) => void > : ^^^^ ^^ ^^^^^ >console : Console diff --git a/tests/baselines/reference/promisePermutations.errors.txt b/tests/baselines/reference/promisePermutations.errors.txt index 55ac1623cccbd..86b419bd2aaf7 100644 --- a/tests/baselines/reference/promisePermutations.errors.txt +++ b/tests/baselines/reference/promisePermutations.errors.txt @@ -140,7 +140,7 @@ promisePermutations.ts(160,21): error TS2769: No overload matches this call. Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => IPromise'. Call signature return types 'Promise' and 'IPromise' are incompatible. The types of 'then' are incompatible between these types. - Type '{ (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. + Type '{ (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. Types of parameters 'onfulfilled' and 'success' are incompatible. Types of parameters 'value' and 'value' are incompatible. Type 'number' is not assignable to type 'string'. @@ -515,7 +515,7 @@ promisePermutations.ts(160,21): error TS2769: No overload matches this call. !!! error TS2769: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => IPromise'. !!! error TS2769: Call signature return types 'Promise' and 'IPromise' are incompatible. !!! error TS2769: The types of 'then' are incompatible between these types. -!!! error TS2769: Type '{ (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. +!!! error TS2769: Type '{ (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. !!! error TS2769: Types of parameters 'onfulfilled' and 'success' are incompatible. !!! error TS2769: Types of parameters 'value' and 'value' are incompatible. !!! error TS2769: Type 'number' is not assignable to type 'string'. diff --git a/tests/baselines/reference/promisePermutations.types b/tests/baselines/reference/promisePermutations.types index 37e91522dd94e..c5975407f3e63 100644 --- a/tests/baselines/reference/promisePermutations.types +++ b/tests/baselines/reference/promisePermutations.types @@ -7,8 +7,8 @@ Instantiation count: 5,000 -> 25,000 === promisePermutations.ts === interface Promise { then(success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => Promise > : ^ ^^ ^^^^^ >value : T @@ -23,8 +23,8 @@ interface Promise { > : ^^^ then(success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => Promise > : ^ ^^ ^^^^^ >value : T @@ -39,8 +39,8 @@ interface Promise { > : ^^^ then(success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => U > : ^ ^^ ^^^^^ >value : T @@ -55,8 +55,8 @@ interface Promise { > : ^^^ then(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => U > : ^ ^^ ^^^^^ >value : T @@ -460,12 +460,12 @@ var s1a = s1.then(testFunction, testFunction, testFunction); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunction, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise @@ -478,12 +478,12 @@ var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP); > : ^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunctionP, testFunctionP) : Promise > : ^^^^^^^^^^^^^^^ ->s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunctionP : () => Promise @@ -496,12 +496,12 @@ var s1c = s1.then(testFunctionP, testFunction, testFunction); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunction : () => IPromise @@ -514,24 +514,24 @@ var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction, > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then(testFunctionP, testFunction, testFunction).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then(testFunctionP, testFunction, testFunction).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1.then(testFunctionP, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise > : ^^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise @@ -604,12 +604,12 @@ var s2a = s2.then(testFunction2, testFunction2, testFunction2); > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -622,12 +622,12 @@ var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P); > : ^^^^^^^^^^^^^ ^^^^ >s2.then(testFunction2P, testFunction2P, testFunction2P) : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2P : () => Promise<{ x: number; }> @@ -640,12 +640,12 @@ var s2c = s2.then(testFunction2P, testFunction2, testFunction2); > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -658,24 +658,24 @@ var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunctio > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then(testFunction2P, testFunction2, testFunction2).then : { , TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then(testFunction2P, testFunction2, testFunction2).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2.then(testFunction2P, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -744,12 +744,12 @@ var s3a = s3.then(testFunction3, testFunction3, testFunction3); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -762,12 +762,12 @@ var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P); > : ^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3P, testFunction3P) : Promise > : ^^^^^^^^^^^^^^^ ->s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3P : (x: number) => Promise @@ -780,12 +780,12 @@ var s3c = s3.then(testFunction3P, testFunction3, testFunction3); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -798,24 +798,24 @@ var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunctio > : ^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : Promise > : ^^^^^^^^^^^^^^^ ->s3.then(testFunction3P, testFunction3, testFunction3).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then(testFunction3P, testFunction3, testFunction3).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3.then(testFunction3P, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -896,12 +896,12 @@ var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error > : ^^^^^^^^^^^^^^^ >s4.then(testFunction4, testFunction4, testFunction4) : Promise > : ^^^^^^^^^^^^^^^ ->s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction4 : (x: number, y?: string) => IPromise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise @@ -914,12 +914,12 @@ var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error > : ^^^^^^^^^^^^^^^ >s4.then(testFunction4P, testFunction4P, testFunction4P) : Promise > : ^^^^^^^^^^^^^^^ ->s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise @@ -932,12 +932,12 @@ var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error > : ^^^^^^^^^^^^^^^ >s4.then(testFunction4P, testFunction4, testFunction4) : Promise > : ^^^^^^^^^^^^^^^ ->s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise @@ -950,24 +950,24 @@ var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, test > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then(sIPromise, testFunction4P, testFunction4).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then(sIPromise, testFunction4P, testFunction4).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4.then(sIPromise, testFunction4P, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise > : ^ ^^ ^^ ^^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise @@ -1036,12 +1036,12 @@ var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error > : ^^^^^^^^^^^^^^^ >s5.then(testFunction5, testFunction5, testFunction5) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise @@ -1054,12 +1054,12 @@ var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error > : ^^^^^^^^^^^^^^^ >s5.then(testFunction5P, testFunction5P, testFunction5P) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise @@ -1072,12 +1072,12 @@ var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error > : ^^^^^^^^^^^^^^^ >s5.then(testFunction5P, testFunction5, testFunction5) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise @@ -1090,24 +1090,24 @@ var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then(sPromise, sPromise, sPromise).then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then(sPromise, sPromise, sPromise).then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1176,12 +1176,12 @@ var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error > : ^^^^^^^^^^^^^^^ >s6.then(testFunction6, testFunction6, testFunction6) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise @@ -1194,12 +1194,12 @@ var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error > : ^^^^^^^^^^^^^^^ >s6.then(testFunction6P, testFunction6P, testFunction6P) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise @@ -1212,12 +1212,12 @@ var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error > : ^^^^^^^^^^^^^^^ >s6.then(testFunction6P, testFunction6, testFunction6) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise @@ -1230,24 +1230,24 @@ var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then(sPromise, sPromise, sPromise).then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then(sPromise, sPromise, sPromise).then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1468,12 +1468,12 @@ var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8, testFunction8, testFunction8) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise @@ -1486,12 +1486,12 @@ var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8P, testFunction8P, testFunction8P) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise @@ -1504,12 +1504,12 @@ var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8P, testFunction8, testFunction8) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise @@ -1522,24 +1522,24 @@ var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s8.then(nIPromise, nIPromise, nIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then(nIPromise, nIPromise, nIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8.then(nIPromise, nIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise @@ -1662,12 +1662,12 @@ var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9, testFunction9, testFunction9) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise @@ -1680,12 +1680,12 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9P, testFunction9P, testFunction9P) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise @@ -1698,12 +1698,12 @@ var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9P, testFunction9, testFunction9) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise @@ -1716,12 +1716,12 @@ var s9d = s9.then(sPromise, sPromise, sPromise); // ok > : ^^^^^^^^^^^^^^^ >s9.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise @@ -1734,12 +1734,12 @@ var s9e = s9.then(nPromise, nPromise, nPromise); // ok > : ^^^^^^^^^^^^^^^ >s9.then(nPromise, nPromise, nPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >nPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >nPromise : (x: any) => Promise @@ -1752,12 +1752,12 @@ var s9f = s9.then(testFunction, sIPromise, nIPromise); // error > : ^^^^^^^^^^^^^^^ >s9.then(testFunction, sIPromise, nIPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction : () => IPromise > : ^^^^^^ >sIPromise : (x: any) => IPromise @@ -1770,24 +1770,24 @@ var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then(testFunction, nIPromise, sIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then(testFunction, nIPromise, sIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9.then(testFunction, nIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction : () => IPromise > : ^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1930,12 +1930,12 @@ var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunction10, testFunction10, testFunction10) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction10 : (cb: (a: U) => U) => IPromise > : ^ ^^ ^^ ^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise @@ -1948,12 +1948,12 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok > : ^^^^^^^^^^^^^^^^ >s10.then(testFunction10P, testFunction10P, testFunction10P) : Promise > : ^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction10P : (cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^^^^ >testFunction10P : (cb: (a: U) => U) => Promise @@ -1966,12 +1966,12 @@ var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok > : ^^^^^^^^^^^^^^^^ >s10.then(testFunction10P, testFunction10, testFunction10) : Promise > : ^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction10P : (cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise @@ -1984,12 +1984,12 @@ var s10d = s10.then(sPromise, sPromise, sPromise); // ok > : ^^^^^^^^^^^^^^^ >s10.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise @@ -2002,12 +2002,12 @@ var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(nIPromise, nPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nPromise : (x: any) => Promise @@ -2020,12 +2020,12 @@ var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error > : ^^^^^^^^^^^^^^^ >s10.then(testFunctionP, sIPromise, nIPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >sIPromise : (x: any) => IPromise @@ -2038,24 +2038,24 @@ var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromis > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then(testFunctionP, nIPromise, sIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then(testFunctionP, nIPromise, sIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10.then(testFunctionP, nIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -2094,12 +2094,12 @@ var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok > : ^^^^^^^^^^^^^^^ >s11.then(testFunction11, testFunction11, testFunction11) : Promise > : ^^^^^^^^^^^^^^^ ->s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } @@ -2112,12 +2112,12 @@ var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error > : ^^^^^^^^^^^^^^^ >s11.then(testFunction11P, testFunction11P, testFunction11P) : Promise > : ^^^^^^^^^^^^^^^ ->s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } @@ -2130,12 +2130,12 @@ var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error > : ^^^^^^^^^^^^^^^ >s11.then(testFunction11P, testFunction11, testFunction11) : Promise > : ^^^^^^^^^^^^^^^ ->s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } diff --git a/tests/baselines/reference/promisePermutations2.errors.txt b/tests/baselines/reference/promisePermutations2.errors.txt index 87559b404a648..f4bc87a3ef985 100644 --- a/tests/baselines/reference/promisePermutations2.errors.txt +++ b/tests/baselines/reference/promisePermutations2.errors.txt @@ -98,7 +98,7 @@ promisePermutations2.ts(158,21): error TS2345: Argument of type '{ (x: number): promisePermutations2.ts(159,21): error TS2345: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => IPromise'. Call signature return types 'Promise' and 'IPromise' are incompatible. The types of 'then' are incompatible between these types. - Type '{ (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. + Type '{ (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. Types of parameters 'onfulfilled' and 'success' are incompatible. Types of parameters 'value' and 'value' are incompatible. Type 'number' is not assignable to type 'string'. @@ -410,7 +410,7 @@ promisePermutations2.ts(159,21): error TS2345: Argument of type '{ (x: number): !!! error TS2345: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => IPromise'. !!! error TS2345: Call signature return types 'Promise' and 'IPromise' are incompatible. !!! error TS2345: The types of 'then' are incompatible between these types. -!!! error TS2345: Type '{ (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. +!!! error TS2345: Type '{ (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. !!! error TS2345: Types of parameters 'onfulfilled' and 'success' are incompatible. !!! error TS2345: Types of parameters 'value' and 'value' are incompatible. !!! error TS2345: Type 'number' is not assignable to type 'string'. diff --git a/tests/baselines/reference/promisePermutations2.types b/tests/baselines/reference/promisePermutations2.types index d7781b8a9ac15..8bf4092bbd1ed 100644 --- a/tests/baselines/reference/promisePermutations2.types +++ b/tests/baselines/reference/promisePermutations2.types @@ -8,8 +8,8 @@ Instantiation count: 2,500 -> 10,000 interface Promise { then(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => U > : ^ ^^ ^^^^^ >value : T @@ -413,12 +413,12 @@ var s1a = s1.then(testFunction, testFunction, testFunction); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunction, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise @@ -431,12 +431,12 @@ var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunctionP, testFunctionP) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunctionP : () => Promise @@ -449,12 +449,12 @@ var s1c = s1.then(testFunctionP, testFunction, testFunction); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunction : () => IPromise @@ -467,24 +467,24 @@ var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction, > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then(testFunctionP, testFunction, testFunction).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then(testFunctionP, testFunction, testFunction).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1.then(testFunctionP, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise > : ^^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise @@ -557,12 +557,12 @@ var s2a = s2.then(testFunction2, testFunction2, testFunction2); > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -575,12 +575,12 @@ var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P); > : ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2P, testFunction2P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2P : () => Promise<{ x: number; }> @@ -593,12 +593,12 @@ var s2c = s2.then(testFunction2P, testFunction2, testFunction2); > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -611,24 +611,24 @@ var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunctio > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then(testFunction2P, testFunction2, testFunction2).then : { , TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then(testFunction2P, testFunction2, testFunction2).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2.then(testFunction2P, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -697,12 +697,12 @@ var s3a = s3.then(testFunction3, testFunction3, testFunction3); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -715,12 +715,12 @@ var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3P, testFunction3P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3P : (x: number) => Promise @@ -733,12 +733,12 @@ var s3c = s3.then(testFunction3P, testFunction3, testFunction3); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -751,24 +751,24 @@ var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunctio > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then(testFunction3P, testFunction3, testFunction3).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then(testFunction3P, testFunction3, testFunction3).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3.then(testFunction3P, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -849,12 +849,12 @@ var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s4.then(testFunction4, testFunction4, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction4 : (x: number, y?: string) => IPromise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise @@ -867,12 +867,12 @@ var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s4.then(testFunction4P, testFunction4P, testFunction4P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise @@ -885,12 +885,12 @@ var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s4.then(testFunction4P, testFunction4, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise @@ -903,24 +903,24 @@ var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, test > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then(sIPromise, testFunction4P, testFunction4).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then(sIPromise, testFunction4P, testFunction4).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4.then(sIPromise, testFunction4P, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise > : ^ ^^ ^^ ^^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise @@ -989,12 +989,12 @@ var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s5.then(testFunction5, testFunction5, testFunction5) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise @@ -1007,12 +1007,12 @@ var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s5.then(testFunction5P, testFunction5P, testFunction5P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise @@ -1025,12 +1025,12 @@ var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s5.then(testFunction5P, testFunction5, testFunction5) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise @@ -1043,24 +1043,24 @@ var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then(sPromise, sPromise, sPromise).then : { , TResult2 = never>(onfulfilled?: (value: Promise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then(sPromise, sPromise, sPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: Promise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5.then(sPromise, sPromise, sPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: Promise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: Promise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1129,12 +1129,12 @@ var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s6.then(testFunction6, testFunction6, testFunction6) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise @@ -1147,12 +1147,12 @@ var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s6.then(testFunction6P, testFunction6P, testFunction6P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise @@ -1165,12 +1165,12 @@ var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s6.then(testFunction6P, testFunction6, testFunction6) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise @@ -1183,24 +1183,24 @@ var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then(sPromise, sPromise, sPromise).then : { , TResult2 = never>(onfulfilled?: (value: Promise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then(sPromise, sPromise, sPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: Promise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6.then(sPromise, sPromise, sPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: Promise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: Promise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1421,12 +1421,12 @@ var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8, testFunction8, testFunction8) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise @@ -1439,12 +1439,12 @@ var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8P, testFunction8P, testFunction8P) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise @@ -1457,12 +1457,12 @@ var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8P, testFunction8, testFunction8) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise @@ -1475,24 +1475,24 @@ var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s8.then(nIPromise, nIPromise, nIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then(nIPromise, nIPromise, nIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8.then(nIPromise, nIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise @@ -1615,12 +1615,12 @@ var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9, testFunction9, testFunction9) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise @@ -1633,12 +1633,12 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9P, testFunction9P, testFunction9P) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise @@ -1651,12 +1651,12 @@ var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9P, testFunction9, testFunction9) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise @@ -1669,12 +1669,12 @@ var s9d = s9.then(sPromise, sPromise, sPromise); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s9.then(sPromise, sPromise, sPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise @@ -1687,12 +1687,12 @@ var s9e = s9.then(nPromise, nPromise, nPromise); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s9.then(nPromise, nPromise, nPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >nPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >nPromise : (x: any) => Promise @@ -1705,12 +1705,12 @@ var s9f = s9.then(testFunction, sIPromise, nIPromise); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s9.then(testFunction, sIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction : () => IPromise > : ^^^^^^ >sIPromise : (x: any) => IPromise @@ -1723,24 +1723,24 @@ var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then(testFunction, nIPromise, sIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then(testFunction, nIPromise, sIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9.then(testFunction, nIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction : () => IPromise > : ^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1883,12 +1883,12 @@ var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunction10, testFunction10, testFunction10) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction10 : (cb: (a: U) => U) => IPromise > : ^ ^^ ^^ ^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise @@ -1901,12 +1901,12 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunction10P, testFunction10P, testFunction10P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction10P : (cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^^^^ >testFunction10P : (cb: (a: U) => U) => Promise @@ -1919,12 +1919,12 @@ var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunction10P, testFunction10, testFunction10) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction10P : (cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise @@ -1937,12 +1937,12 @@ var s10d = s10.then(sPromise, sPromise, sPromise); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(sPromise, sPromise, sPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise @@ -1955,12 +1955,12 @@ var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(nIPromise, nPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nPromise : (x: any) => Promise @@ -1973,12 +1973,12 @@ var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunctionP, sIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >sIPromise : (x: any) => IPromise @@ -1991,24 +1991,24 @@ var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromis > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then(testFunctionP, nIPromise, sIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then(testFunctionP, nIPromise, sIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10.then(testFunctionP, nIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -2047,12 +2047,12 @@ var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s11.then(testFunction11, testFunction11, testFunction11) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } @@ -2065,12 +2065,12 @@ var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s11.then(testFunction11P, testFunction11P, testFunction11P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } @@ -2083,12 +2083,12 @@ var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s11.then(testFunction11P, testFunction11, testFunction11) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } diff --git a/tests/baselines/reference/promisePermutations3.errors.txt b/tests/baselines/reference/promisePermutations3.errors.txt index 4b653256db3e7..7be29477e655d 100644 --- a/tests/baselines/reference/promisePermutations3.errors.txt +++ b/tests/baselines/reference/promisePermutations3.errors.txt @@ -119,7 +119,7 @@ promisePermutations3.ts(159,21): error TS2769: No overload matches this call. Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => IPromise'. Call signature return types 'Promise' and 'IPromise' are incompatible. The types of 'then' are incompatible between these types. - Type '{ (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise'. + Type '{ (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise'. Types of parameters 'onfulfilled' and 'success' are incompatible. Types of parameters 'value' and 'value' are incompatible. Type 'number' is not assignable to type 'string'. @@ -463,7 +463,7 @@ promisePermutations3.ts(165,21): error TS2345: Argument of type '{ (x: T): IP !!! error TS2769: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => IPromise'. !!! error TS2769: Call signature return types 'Promise' and 'IPromise' are incompatible. !!! error TS2769: The types of 'then' are incompatible between these types. -!!! error TS2769: Type '{ (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise'. +!!! error TS2769: Type '{ (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise'. !!! error TS2769: Types of parameters 'onfulfilled' and 'success' are incompatible. !!! error TS2769: Types of parameters 'value' and 'value' are incompatible. !!! error TS2769: Type 'number' is not assignable to type 'string'. diff --git a/tests/baselines/reference/promisePermutations3.types b/tests/baselines/reference/promisePermutations3.types index e59283afc6d1e..86f4a6f1ff219 100644 --- a/tests/baselines/reference/promisePermutations3.types +++ b/tests/baselines/reference/promisePermutations3.types @@ -9,8 +9,8 @@ Instantiation count: 5,000 -> 25,000 interface Promise { then(success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => Promise > : ^ ^^ ^^^^^ >value : T @@ -25,8 +25,8 @@ interface Promise { > : ^^^ then(success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => Promise > : ^ ^^ ^^^^^ >value : T @@ -41,8 +41,8 @@ interface Promise { > : ^^^ then(success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => U > : ^ ^^ ^^^^^ >value : T @@ -57,8 +57,8 @@ interface Promise { > : ^^^ then(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => U > : ^ ^^ ^^^^^ >value : T @@ -414,12 +414,12 @@ var s1a = s1.then(testFunction, testFunction, testFunction); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunction, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise @@ -432,12 +432,12 @@ var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP); > : ^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunctionP, testFunctionP) : Promise > : ^^^^^^^^^^^^^^^ ->s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunctionP : () => Promise @@ -450,12 +450,12 @@ var s1c = s1.then(testFunctionP, testFunction, testFunction); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunction : () => IPromise @@ -468,24 +468,24 @@ var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction, > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then(testFunctionP, testFunction, testFunction).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then(testFunctionP, testFunction, testFunction).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1.then(testFunctionP, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise > : ^^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise @@ -558,12 +558,12 @@ var s2a = s2.then(testFunction2, testFunction2, testFunction2); > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -576,12 +576,12 @@ var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P); > : ^^^^^^^^^^^^^ ^^^^ >s2.then(testFunction2P, testFunction2P, testFunction2P) : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2P : () => Promise<{ x: number; }> @@ -594,12 +594,12 @@ var s2c = s2.then(testFunction2P, testFunction2, testFunction2); > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -612,24 +612,24 @@ var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunctio > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then(testFunction2P, testFunction2, testFunction2).then : { , TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then(testFunction2P, testFunction2, testFunction2).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2.then(testFunction2P, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -698,12 +698,12 @@ var s3a = s3.then(testFunction3, testFunction3, testFunction3); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -716,12 +716,12 @@ var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P); > : ^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3P, testFunction3P) : Promise > : ^^^^^^^^^^^^^^^ ->s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3P : (x: number) => Promise @@ -734,12 +734,12 @@ var s3c = s3.then(testFunction3P, testFunction3, testFunction3); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -752,24 +752,24 @@ var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunctio > : ^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : Promise > : ^^^^^^^^^^^^^^^ ->s3.then(testFunction3P, testFunction3, testFunction3).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then(testFunction3P, testFunction3, testFunction3).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3.then(testFunction3P, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -850,12 +850,12 @@ var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error > : ^^^^^^^^^^^^^^^ >s4.then(testFunction4, testFunction4, testFunction4) : Promise > : ^^^^^^^^^^^^^^^ ->s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction4 : (x: number, y?: string) => IPromise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise @@ -868,12 +868,12 @@ var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error > : ^^^^^^^^^^^^^^^ >s4.then(testFunction4P, testFunction4P, testFunction4P) : Promise > : ^^^^^^^^^^^^^^^ ->s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise @@ -886,12 +886,12 @@ var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error > : ^^^^^^^^^^^^^^^ >s4.then(testFunction4P, testFunction4, testFunction4) : Promise > : ^^^^^^^^^^^^^^^ ->s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise @@ -904,24 +904,24 @@ var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, test > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then(sIPromise, testFunction4P, testFunction4).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then(sIPromise, testFunction4P, testFunction4).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4.then(sIPromise, testFunction4P, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise > : ^ ^^ ^^ ^^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise @@ -990,12 +990,12 @@ var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error > : ^^^^^^^^^^^^^^^ >s5.then(testFunction5, testFunction5, testFunction5) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise @@ -1008,12 +1008,12 @@ var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error > : ^^^^^^^^^^^^^^^ >s5.then(testFunction5P, testFunction5P, testFunction5P) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise @@ -1026,12 +1026,12 @@ var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error > : ^^^^^^^^^^^^^^^ >s5.then(testFunction5P, testFunction5, testFunction5) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise @@ -1044,24 +1044,24 @@ var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then(sPromise, sPromise, sPromise).then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then(sPromise, sPromise, sPromise).then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1130,12 +1130,12 @@ var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error > : ^^^^^^^^^^^^^^^ >s6.then(testFunction6, testFunction6, testFunction6) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise @@ -1148,12 +1148,12 @@ var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error > : ^^^^^^^^^^^^^^^ >s6.then(testFunction6P, testFunction6P, testFunction6P) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise @@ -1166,12 +1166,12 @@ var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error > : ^^^^^^^^^^^^^^^ >s6.then(testFunction6P, testFunction6, testFunction6) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise @@ -1184,24 +1184,24 @@ var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then(sPromise, sPromise, sPromise).then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then(sPromise, sPromise, sPromise).then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ ->then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1422,12 +1422,12 @@ var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8, testFunction8, testFunction8) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise @@ -1440,12 +1440,12 @@ var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8P, testFunction8P, testFunction8P) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise @@ -1458,12 +1458,12 @@ var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8P, testFunction8, testFunction8) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise @@ -1476,24 +1476,24 @@ var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s8.then(nIPromise, nIPromise, nIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then(nIPromise, nIPromise, nIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8.then(nIPromise, nIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise @@ -1616,12 +1616,12 @@ var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9, testFunction9, testFunction9) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise @@ -1634,12 +1634,12 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9P, testFunction9P, testFunction9P) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise @@ -1652,12 +1652,12 @@ var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9P, testFunction9, testFunction9) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise @@ -1670,12 +1670,12 @@ var s9d = s9.then(sPromise, sPromise, sPromise); // ok > : ^^^^^^^^^^^^^^^ >s9.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise @@ -1688,12 +1688,12 @@ var s9e = s9.then(nPromise, nPromise, nPromise); // ok > : ^^^^^^^^^^^^^^^ >s9.then(nPromise, nPromise, nPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >nPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >nPromise : (x: any) => Promise @@ -1706,12 +1706,12 @@ var s9f = s9.then(testFunction, sIPromise, nIPromise); // error > : ^^^^^^^^^^^^^^^ >s9.then(testFunction, sIPromise, nIPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction : () => IPromise > : ^^^^^^ >sIPromise : (x: any) => IPromise @@ -1724,24 +1724,24 @@ var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then(testFunction, nIPromise, sIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then(testFunction, nIPromise, sIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9.then(testFunction, nIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction : () => IPromise > : ^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1884,12 +1884,12 @@ var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunction10, testFunction10, testFunction10) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction10 : (cb: (a: U) => U) => IPromise > : ^ ^^ ^^ ^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise @@ -1902,12 +1902,12 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok > : ^^^^^^^^^^^^^^^^ >s10.then(testFunction10P, testFunction10P, testFunction10P) : Promise > : ^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction10P : (cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^^^^ >testFunction10P : (cb: (a: U) => U) => Promise @@ -1920,12 +1920,12 @@ var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok > : ^^^^^^^^^^^^^^^^ >s10.then(testFunction10P, testFunction10, testFunction10) : Promise > : ^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction10P : (cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise @@ -1938,12 +1938,12 @@ var s10d = s10.then(sPromise, sPromise, sPromise); // ok > : ^^^^^^^^^^^^^^^ >s10.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise @@ -1956,12 +1956,12 @@ var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(nIPromise, nPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nPromise : (x: any) => Promise @@ -1974,12 +1974,12 @@ var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error > : ^^^^^^^^^^^^^^^ >s10.then(testFunctionP, sIPromise, nIPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >sIPromise : (x: any) => IPromise @@ -1992,24 +1992,24 @@ var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromis > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then(testFunctionP, nIPromise, sIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then(testFunctionP, nIPromise, sIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10.then(testFunctionP, nIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunctionP : () => Promise > : ^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -2048,12 +2048,12 @@ var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok > : ^^^^^^^^^^^^^^^ >s11.then(testFunction11, testFunction11, testFunction11) : Promise > : ^^^^^^^^^^^^^^^ ->s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } @@ -2066,12 +2066,12 @@ var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error > : ^^^^^^^^^^^^^^^ >s11.then(testFunction11P, testFunction11P, testFunction11P) : Promise > : ^^^^^^^^^^^^^^^ ->s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } @@ -2084,12 +2084,12 @@ var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error > : ^^^^^^^^^^^^^^^ >s11.then(testFunction11P, testFunction11, testFunction11) : Promise > : ^^^^^^^^^^^^^^^ ->s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^ ^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^ ^ ^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } diff --git a/tests/baselines/reference/promiseTest.types b/tests/baselines/reference/promiseTest.types index f97721783ae83..c0dad4ea3ddfc 100644 --- a/tests/baselines/reference/promiseTest.types +++ b/tests/baselines/reference/promiseTest.types @@ -3,16 +3,16 @@ === promiseTest.ts === interface Promise { then(success?: (value: T) => Promise): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise): Promise; (success?: (value: T) => B): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise): Promise; (success?: (value: T) => B): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => Promise > : ^ ^^ ^^^^^ >value : T > : ^ then(success?: (value: T) => B): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise): Promise; (success?: (value: T) => B): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise): Promise; (success?: (value: T) => B): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => B > : ^ ^^ ^^^^^ >value : T @@ -32,12 +32,12 @@ var p2 = p.then(function (x) { > : ^^^^^^^^^^^^^^^ >p.then(function (x) { return p;} ) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise): Promise; (success?: (value: number) => B): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^ ^^^ +>p.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise): Promise; (success?: (value: number) => B): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^ ^^^ >p : Promise > : ^^^^^^^^^^^^^^^ ->then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise): Promise; (success?: (value: number) => B): Promise; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^ ^^^ +>then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise): Promise; (success?: (value: number) => B): Promise; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^ ^ ^^^ ^ ^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^ ^^^ >function (x) { return p;} : (x: number) => Promise > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >x : number diff --git a/tests/baselines/reference/promiseType.types b/tests/baselines/reference/promiseType.types index 570177cdd0a33..fe10d8f394a0c 100644 --- a/tests/baselines/reference/promiseType.types +++ b/tests/baselines/reference/promiseType.types @@ -252,36 +252,36 @@ const p00 = p.catch(); > : ^^^^^^^^^^^^^^^^ >p.catch() : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ const p01 = p.then(); >p01 : Promise > : ^^^^^^^^^^^^^^^^ >p.then() : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ const p10 = p.catch(undefined); >p10 : Promise > : ^^^^^^^^^^^^^^^^ >p.catch(undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -290,24 +290,24 @@ const p11 = p.catch(null); > : ^^^^^^^^^^^^^^^^ >p.catch(null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ const p12 = p.catch(() => 1); >p12 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >() => 1 : () => number > : ^^^^^^^^^^^^ >1 : 1 @@ -318,12 +318,12 @@ const p13 = p.catch(() => x); > : ^^^^^^^^^^^^ >p.catch(() => x) : Promise > : ^^^^^^^^^^^^ ->p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -333,12 +333,12 @@ const p14 = p.catch(() => undefined); > : ^^^^^^^^^^^^ >p.catch(() => undefined) : Promise > : ^^^^^^^^^^^^ ->p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -349,12 +349,12 @@ const p15 = p.catch(() => null); > : ^^^^^^^^^^^^ >p.catch(() => null) : Promise > : ^^^^^^^^^^^^ ->p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >() => null : () => any > : ^^^^^^^^^ @@ -363,12 +363,12 @@ const p16 = p.catch(() => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -377,12 +377,12 @@ const p17 = p.catch(() => {throw 1}); > : ^^^^^^^^^^^^^^^^ >p.catch(() => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -393,12 +393,12 @@ const p18 = p.catch(() => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^ >p.catch(() => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >() => Promise.reject(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject(1) : Promise @@ -417,12 +417,12 @@ const p19 = p.catch(() => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^ ^^^^^^^ ^^^^^^^ >() => Promise.resolve(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve(1) : Promise @@ -441,12 +441,12 @@ const p20 = p.then(undefined); > : ^^^^^^^^^^^^^^^^ >p.then(undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -455,24 +455,24 @@ const p21 = p.then(null); > : ^^^^^^^^^^^^^^^^ >p.then(null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ const p22 = p.then(() => 1); >p22 : Promise > : ^^^^^^^^^^^^^^^ >p.then(() => 1) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => 1 : () => number > : ^^^^^^^^^^^^ >1 : 1 @@ -483,12 +483,12 @@ const p23 = p.then(() => x); > : ^^^^^^^^^^^^ >p.then(() => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -498,12 +498,12 @@ const p24 = p.then(() => undefined); > : ^^^^^^^^^^^^ >p.then(() => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -514,12 +514,12 @@ const p25 = p.then(() => null); > : ^^^^^^^^^^^^ >p.then(() => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ @@ -528,12 +528,12 @@ const p26 = p.then(() => {}); > : ^^^^^^^^^^^^^ >p.then(() => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -542,12 +542,12 @@ const p27 = p.then(() => {throw 1}); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -558,12 +558,12 @@ const p28 = p.then(() => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve(1) : Promise @@ -582,12 +582,12 @@ const p29 = p.then(() => Promise.reject(1)); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject(1) : Promise @@ -606,12 +606,12 @@ const p30 = p.then(undefined, undefined); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >undefined : undefined @@ -622,12 +622,12 @@ const p31 = p.then(undefined, null); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -636,12 +636,12 @@ const p32 = p.then(undefined, () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => 1 : () => number @@ -654,12 +654,12 @@ const p33 = p.then(undefined, () => x); > : ^^^^^^^^^^^^ >p.then(undefined, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => x : () => any @@ -671,12 +671,12 @@ const p34 = p.then(undefined, () => undefined); > : ^^^^^^^^^^^^ >p.then(undefined, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => undefined : () => any @@ -689,12 +689,12 @@ const p35 = p.then(undefined, () => null); > : ^^^^^^^^^^^^ >p.then(undefined, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => null : () => any @@ -705,12 +705,12 @@ const p36 = p.then(undefined, () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => {} : () => void @@ -721,12 +721,12 @@ const p37 = p.then(undefined, () => {throw 1}); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => {throw 1} : () => never @@ -739,12 +739,12 @@ const p38 = p.then(undefined, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => Promise.resolve(1) : () => Promise @@ -765,12 +765,12 @@ const p39 = p.then(undefined, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => Promise.reject(1) : () => Promise @@ -791,12 +791,12 @@ const p40 = p.then(null, undefined); > : ^^^^^^^^^^^^^^^^ >p.then(null, undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -805,24 +805,24 @@ const p41 = p.then(null, null); > : ^^^^^^^^^^^^^^^^ >p.then(null, null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ const p42 = p.then(null, () => 1); >p42 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => 1 : () => number > : ^^^^^^^^^^^^ >1 : 1 @@ -833,12 +833,12 @@ const p43 = p.then(null, () => x); > : ^^^^^^^^^^^^ >p.then(null, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -848,12 +848,12 @@ const p44 = p.then(null, () => undefined); > : ^^^^^^^^^^^^ >p.then(null, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -864,12 +864,12 @@ const p45 = p.then(null, () => null); > : ^^^^^^^^^^^^ >p.then(null, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ @@ -878,12 +878,12 @@ const p46 = p.then(null, () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -892,12 +892,12 @@ const p47 = p.then(null, () => {throw 1}); > : ^^^^^^^^^^^^^^^^ >p.then(null, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -908,12 +908,12 @@ const p48 = p.then(null, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve(1) : Promise @@ -932,12 +932,12 @@ const p49 = p.then(null, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^ >p.then(null, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject(1) : Promise @@ -956,12 +956,12 @@ const p50 = p.then(() => "1", undefined); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", undefined) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -974,12 +974,12 @@ const p51 = p.then(() => "1", null); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", null) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -990,12 +990,12 @@ const p52 = p.then(() => "1", () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1010,12 +1010,12 @@ const p53 = p.then(() => "1", () => x); > : ^^^^^^^^^^^^ >p.then(() => "1", () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1029,12 +1029,12 @@ const p54 = p.then(() => "1", () => undefined); > : ^^^^^^^^^^^^ >p.then(() => "1", () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1049,12 +1049,12 @@ const p55 = p.then(() => "1", () => null); > : ^^^^^^^^^^^^ >p.then(() => "1", () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1067,12 +1067,12 @@ const p56 = p.then(() => "1", () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1085,12 +1085,12 @@ const p57 = p.then(() => "1", () => {throw 1}); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1105,12 +1105,12 @@ const p58 = p.then(() => "1", () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1133,12 +1133,12 @@ const p59 = p.then(() => "1", () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1161,12 +1161,12 @@ const p60 = p.then(() => x, undefined); > : ^^^^^^^^^^^^ >p.then(() => x, undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1178,12 +1178,12 @@ const p61 = p.then(() => x, null); > : ^^^^^^^^^^^^ >p.then(() => x, null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1193,12 +1193,12 @@ const p62 = p.then(() => x, () => 1); > : ^^^^^^^^^^^^ >p.then(() => x, () => 1) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1212,12 +1212,12 @@ const p63 = p.then(() => x, () => x); > : ^^^^^^^^^^^^ >p.then(() => x, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1230,12 +1230,12 @@ const p64 = p.then(() => x, () => undefined); > : ^^^^^^^^^^^^ >p.then(() => x, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1249,12 +1249,12 @@ const p65 = p.then(() => x, () => null); > : ^^^^^^^^^^^^ >p.then(() => x, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1266,12 +1266,12 @@ const p66 = p.then(() => x, () => {}); > : ^^^^^^^^^^^^ >p.then(() => x, () => {}) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1283,12 +1283,12 @@ const p67 = p.then(() => x, () => {throw 1}); > : ^^^^^^^^^^^^ >p.then(() => x, () => {throw 1}) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1302,12 +1302,12 @@ const p68 = p.then(() => x, () => Promise.resolve(1)); > : ^^^^^^^^^^^^ >p.then(() => x, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1329,12 +1329,12 @@ const p69 = p.then(() => x, () => Promise.reject(1)); > : ^^^^^^^^^^^^ >p.then(() => x, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1356,12 +1356,12 @@ const p70 = p.then(() => undefined, undefined); > : ^^^^^^^^^^^^ >p.then(() => undefined, undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1374,12 +1374,12 @@ const p71 = p.then(() => undefined, null); > : ^^^^^^^^^^^^ >p.then(() => undefined, null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1390,12 +1390,12 @@ const p72 = p.then(() => undefined, () => 1); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => 1) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1410,12 +1410,12 @@ const p73 = p.then(() => undefined, () => x); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1429,12 +1429,12 @@ const p74 = p.then(() => undefined, () => undefined); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1449,12 +1449,12 @@ const p75 = p.then(() => undefined, () => null); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1467,12 +1467,12 @@ const p76 = p.then(() => undefined, () => {}); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => {}) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1485,12 +1485,12 @@ const p77 = p.then(() => undefined, () => {throw 1}); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => {throw 1}) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1505,12 +1505,12 @@ const p78 = p.then(() => undefined, () => Promise.resolve(1)); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1533,12 +1533,12 @@ const p79 = p.then(() => undefined, () => Promise.reject(1)); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1561,12 +1561,12 @@ const p80 = p.then(() => null, undefined); > : ^^^^^^^^^^^^ >p.then(() => null, undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1577,12 +1577,12 @@ const p81 = p.then(() => null, null); > : ^^^^^^^^^^^^ >p.then(() => null, null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ @@ -1591,12 +1591,12 @@ const p82 = p.then(() => null, () => 1); > : ^^^^^^^^^^^^ >p.then(() => null, () => 1) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => 1 : () => number @@ -1609,12 +1609,12 @@ const p83 = p.then(() => null, () => x); > : ^^^^^^^^^^^^ >p.then(() => null, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => x : () => any @@ -1626,12 +1626,12 @@ const p84 = p.then(() => null, () => undefined); > : ^^^^^^^^^^^^ >p.then(() => null, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => undefined : () => any @@ -1644,12 +1644,12 @@ const p85 = p.then(() => null, () => null); > : ^^^^^^^^^^^^ >p.then(() => null, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => null : () => any @@ -1660,12 +1660,12 @@ const p86 = p.then(() => null, () => {}); > : ^^^^^^^^^^^^ >p.then(() => null, () => {}) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => {} : () => void @@ -1676,12 +1676,12 @@ const p87 = p.then(() => null, () => {throw 1}); > : ^^^^^^^^^^^^ >p.then(() => null, () => {throw 1}) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => {throw 1} : () => never @@ -1694,12 +1694,12 @@ const p88 = p.then(() => null, () => Promise.resolve(1)); > : ^^^^^^^^^^^^ >p.then(() => null, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => Promise.resolve(1) : () => Promise @@ -1720,12 +1720,12 @@ const p89 = p.then(() => null, () => Promise.reject(1)); > : ^^^^^^^^^^^^ >p.then(() => null, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => Promise.reject(1) : () => Promise @@ -1746,12 +1746,12 @@ const p90 = p.then(() => {}, undefined); > : ^^^^^^^^^^^^^ >p.then(() => {}, undefined) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >undefined : undefined @@ -1762,12 +1762,12 @@ const p91 = p.then(() => {}, null); > : ^^^^^^^^^^^^^ >p.then(() => {}, null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -1776,12 +1776,12 @@ const p92 = p.then(() => {}, () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => {}, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => 1 : () => number @@ -1794,12 +1794,12 @@ const p93 = p.then(() => {}, () => x); > : ^^^^^^^^^^^^ >p.then(() => {}, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => x : () => any @@ -1811,12 +1811,12 @@ const p94 = p.then(() => {}, () => undefined); > : ^^^^^^^^^^^^ >p.then(() => {}, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => undefined : () => any @@ -1829,12 +1829,12 @@ const p95 = p.then(() => {}, () => null); > : ^^^^^^^^^^^^ >p.then(() => {}, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => null : () => any @@ -1845,12 +1845,12 @@ const p96 = p.then(() => {}, () => {}); > : ^^^^^^^^^^^^^ >p.then(() => {}, () => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => {} : () => void @@ -1861,12 +1861,12 @@ const p97 = p.then(() => {}, () => {throw 1}); > : ^^^^^^^^^^^^^ >p.then(() => {}, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => {throw 1} : () => never @@ -1879,12 +1879,12 @@ const p98 = p.then(() => {}, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => {}, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => Promise.resolve(1) : () => Promise @@ -1905,12 +1905,12 @@ const p99 = p.then(() => {}, () => Promise.reject(1)); > : ^^^^^^^^^^^^^ >p.then(() => {}, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => Promise.reject(1) : () => Promise @@ -1931,12 +1931,12 @@ const pa0 = p.then(() => {throw 1}, undefined); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, undefined) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -1949,12 +1949,12 @@ const pa1 = p.then(() => {throw 1}, null); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, null) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -1965,12 +1965,12 @@ const pa2 = p.then(() => {throw 1}, () => 1); > : ^^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => 1) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -1985,12 +1985,12 @@ const pa3 = p.then(() => {throw 1}, () => x); > : ^^^^^^^^^^^^ >p.then(() => {throw 1}, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2004,12 +2004,12 @@ const pa4 = p.then(() => {throw 1}, () => undefined); > : ^^^^^^^^^^^^ >p.then(() => {throw 1}, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2024,12 +2024,12 @@ const pa5 = p.then(() => {throw 1}, () => null); > : ^^^^^^^^^^^^ >p.then(() => {throw 1}, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2042,12 +2042,12 @@ const pa6 = p.then(() => {throw 1}, () => {}); > : ^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2060,12 +2060,12 @@ const pa7 = p.then(() => {throw 1}, () => {throw 1}); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2080,12 +2080,12 @@ const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2108,12 +2108,12 @@ const pa9 = p.then(() => {throw 1}, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2136,12 +2136,12 @@ const pb0 = p.then(() => Promise.resolve("1"), undefined); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), undefined) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2162,12 +2162,12 @@ const pb1 = p.then(() => Promise.resolve("1"), null); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), null) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2186,12 +2186,12 @@ const pb2 = p.then(() => Promise.resolve("1"), () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2214,12 +2214,12 @@ const pb3 = p.then(() => Promise.resolve("1"), () => x); > : ^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2241,12 +2241,12 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined); > : ^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2269,12 +2269,12 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null); > : ^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2295,12 +2295,12 @@ const pb6 = p.then(() => Promise.resolve("1"), () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2321,12 +2321,12 @@ const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1}); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2349,12 +2349,12 @@ const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2385,12 +2385,12 @@ const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2421,12 +2421,12 @@ const pc0 = p.then(() => Promise.reject("1"), undefined); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), undefined) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2447,12 +2447,12 @@ const pc1 = p.then(() => Promise.reject("1"), null); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), null) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2471,12 +2471,12 @@ const pc2 = p.then(() => Promise.reject("1"), () => 1); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => 1) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2499,12 +2499,12 @@ const pc3 = p.then(() => Promise.reject("1"), () => x); > : ^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2526,12 +2526,12 @@ const pc4 = p.then(() => Promise.reject("1"), () => undefined); > : ^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2554,12 +2554,12 @@ const pc5 = p.then(() => Promise.reject("1"), () => null); > : ^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2580,12 +2580,12 @@ const pc6 = p.then(() => Promise.reject("1"), () => {}); > : ^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2606,12 +2606,12 @@ const pc7 = p.then(() => Promise.reject("1"), () => {throw 1}); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2634,12 +2634,12 @@ const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2670,12 +2670,12 @@ const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1)); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise diff --git a/tests/baselines/reference/promiseTypeStrictNull.types b/tests/baselines/reference/promiseTypeStrictNull.types index c7d7aa3a3b6f7..e2ef04fd42af3 100644 --- a/tests/baselines/reference/promiseTypeStrictNull.types +++ b/tests/baselines/reference/promiseTypeStrictNull.types @@ -252,36 +252,36 @@ const p00 = p.catch(); > : ^^^^^^^^^^^^^^^^ >p.catch() : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ const p01 = p.then(); >p01 : Promise > : ^^^^^^^^^^^^^^^^ >p.then() : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ const p10 = p.catch(undefined); >p10 : Promise > : ^^^^^^^^^^^^^^^^ >p.catch(undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -290,24 +290,24 @@ const p11 = p.catch(null); > : ^^^^^^^^^^^^^^^^ >p.catch(null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ const p12 = p.catch(() => 1); >p12 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >() => 1 : () => number > : ^^^^^^^^^^^^ >1 : 1 @@ -318,12 +318,12 @@ const p13 = p.catch(() => x); > : ^^^^^^^^^^^^ >p.catch(() => x) : Promise > : ^^^^^^^^^^^^ ->p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -333,12 +333,12 @@ const p14 = p.catch(() => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -349,12 +349,12 @@ const p15 = p.catch(() => null); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ @@ -363,12 +363,12 @@ const p16 = p.catch(() => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -377,12 +377,12 @@ const p17 = p.catch(() => {throw 1}); > : ^^^^^^^^^^^^^^^^ >p.catch(() => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -393,12 +393,12 @@ const p18 = p.catch(() => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^ >p.catch(() => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >() => Promise.reject(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject(1) : Promise @@ -417,12 +417,12 @@ const p19 = p.catch(() => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ +>catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^ >() => Promise.resolve(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve(1) : Promise @@ -441,12 +441,12 @@ const p20 = p.then(undefined); > : ^^^^^^^^^^^^^^^^ >p.then(undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -455,24 +455,24 @@ const p21 = p.then(null); > : ^^^^^^^^^^^^^^^^ >p.then(null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ const p22 = p.then(() => 1); >p22 : Promise > : ^^^^^^^^^^^^^^^ >p.then(() => 1) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => 1 : () => number > : ^^^^^^^^^^^^ >1 : 1 @@ -483,12 +483,12 @@ const p23 = p.then(() => x); > : ^^^^^^^^^^^^ >p.then(() => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -498,12 +498,12 @@ const p24 = p.then(() => undefined); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -514,12 +514,12 @@ const p25 = p.then(() => null); > : ^^^^^^^^^^^^^ >p.then(() => null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ @@ -528,12 +528,12 @@ const p26 = p.then(() => {}); > : ^^^^^^^^^^^^^ >p.then(() => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -542,12 +542,12 @@ const p27 = p.then(() => {throw 1}); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -558,12 +558,12 @@ const p28 = p.then(() => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve(1) : Promise @@ -582,12 +582,12 @@ const p29 = p.then(() => Promise.reject(1)); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject(1) : Promise @@ -606,12 +606,12 @@ const p30 = p.then(undefined, undefined); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >undefined : undefined @@ -622,12 +622,12 @@ const p31 = p.then(undefined, null); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -636,12 +636,12 @@ const p32 = p.then(undefined, () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => 1 : () => number @@ -654,12 +654,12 @@ const p33 = p.then(undefined, () => x); > : ^^^^^^^^^^^^ >p.then(undefined, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => x : () => any @@ -671,12 +671,12 @@ const p34 = p.then(undefined, () => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => undefined : () => undefined @@ -689,12 +689,12 @@ const p35 = p.then(undefined, () => null); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => null : () => null @@ -705,12 +705,12 @@ const p36 = p.then(undefined, () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => {} : () => void @@ -721,12 +721,12 @@ const p37 = p.then(undefined, () => {throw 1}); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => {throw 1} : () => never @@ -739,12 +739,12 @@ const p38 = p.then(undefined, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => Promise.resolve(1) : () => Promise @@ -765,12 +765,12 @@ const p39 = p.then(undefined, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => Promise.reject(1) : () => Promise @@ -791,12 +791,12 @@ const p40 = p.then(null, undefined); > : ^^^^^^^^^^^^^^^^ >p.then(null, undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -805,24 +805,24 @@ const p41 = p.then(null, null); > : ^^^^^^^^^^^^^^^^ >p.then(null, null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ const p42 = p.then(null, () => 1); >p42 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => 1 : () => number > : ^^^^^^^^^^^^ >1 : 1 @@ -833,12 +833,12 @@ const p43 = p.then(null, () => x); > : ^^^^^^^^^^^^ >p.then(null, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -848,12 +848,12 @@ const p44 = p.then(null, () => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -864,12 +864,12 @@ const p45 = p.then(null, () => null); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ @@ -878,12 +878,12 @@ const p46 = p.then(null, () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -892,12 +892,12 @@ const p47 = p.then(null, () => {throw 1}); > : ^^^^^^^^^^^^^^^^ >p.then(null, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -908,12 +908,12 @@ const p48 = p.then(null, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve(1) : Promise @@ -932,12 +932,12 @@ const p49 = p.then(null, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^ >p.then(null, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject(1) : Promise @@ -956,12 +956,12 @@ const p50 = p.then(() => "1", undefined); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", undefined) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -974,12 +974,12 @@ const p51 = p.then(() => "1", null); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", null) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -990,12 +990,12 @@ const p52 = p.then(() => "1", () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1010,12 +1010,12 @@ const p53 = p.then(() => "1", () => x); > : ^^^^^^^^^^^^ >p.then(() => "1", () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1029,12 +1029,12 @@ const p54 = p.then(() => "1", () => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1049,12 +1049,12 @@ const p55 = p.then(() => "1", () => null); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1067,12 +1067,12 @@ const p56 = p.then(() => "1", () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1085,12 +1085,12 @@ const p57 = p.then(() => "1", () => {throw 1}); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1105,12 +1105,12 @@ const p58 = p.then(() => "1", () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1133,12 +1133,12 @@ const p59 = p.then(() => "1", () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1161,12 +1161,12 @@ const p60 = p.then(() => x, undefined); > : ^^^^^^^^^^^^ >p.then(() => x, undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1178,12 +1178,12 @@ const p61 = p.then(() => x, null); > : ^^^^^^^^^^^^ >p.then(() => x, null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1193,12 +1193,12 @@ const p62 = p.then(() => x, () => 1); > : ^^^^^^^^^^^^ >p.then(() => x, () => 1) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1212,12 +1212,12 @@ const p63 = p.then(() => x, () => x); > : ^^^^^^^^^^^^ >p.then(() => x, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1230,12 +1230,12 @@ const p64 = p.then(() => x, () => undefined); > : ^^^^^^^^^^^^ >p.then(() => x, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1249,12 +1249,12 @@ const p65 = p.then(() => x, () => null); > : ^^^^^^^^^^^^ >p.then(() => x, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1266,12 +1266,12 @@ const p66 = p.then(() => x, () => {}); > : ^^^^^^^^^^^^ >p.then(() => x, () => {}) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1283,12 +1283,12 @@ const p67 = p.then(() => x, () => {throw 1}); > : ^^^^^^^^^^^^ >p.then(() => x, () => {throw 1}) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1302,12 +1302,12 @@ const p68 = p.then(() => x, () => Promise.resolve(1)); > : ^^^^^^^^^^^^ >p.then(() => x, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1329,12 +1329,12 @@ const p69 = p.then(() => x, () => Promise.reject(1)); > : ^^^^^^^^^^^^ >p.then(() => x, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1356,12 +1356,12 @@ const p70 = p.then(() => undefined, undefined); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, undefined) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1374,12 +1374,12 @@ const p71 = p.then(() => undefined, null); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, null) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1390,12 +1390,12 @@ const p72 = p.then(() => undefined, () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1410,12 +1410,12 @@ const p73 = p.then(() => undefined, () => x); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1429,12 +1429,12 @@ const p74 = p.then(() => undefined, () => undefined); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1449,12 +1449,12 @@ const p75 = p.then(() => undefined, () => null); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1467,12 +1467,12 @@ const p76 = p.then(() => undefined, () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1485,12 +1485,12 @@ const p77 = p.then(() => undefined, () => {throw 1}); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1505,12 +1505,12 @@ const p78 = p.then(() => undefined, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1533,12 +1533,12 @@ const p79 = p.then(() => undefined, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1561,12 +1561,12 @@ const p80 = p.then(() => null, undefined); > : ^^^^^^^^^^^^^ >p.then(() => null, undefined) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >undefined : undefined @@ -1577,12 +1577,12 @@ const p81 = p.then(() => null, null); > : ^^^^^^^^^^^^^ >p.then(() => null, null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ @@ -1591,12 +1591,12 @@ const p82 = p.then(() => null, () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => null, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => 1 : () => number @@ -1609,12 +1609,12 @@ const p83 = p.then(() => null, () => x); > : ^^^^^^^^^^^^ >p.then(() => null, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => x : () => any @@ -1626,12 +1626,12 @@ const p84 = p.then(() => null, () => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => null, () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => undefined : () => undefined @@ -1644,12 +1644,12 @@ const p85 = p.then(() => null, () => null); > : ^^^^^^^^^^^^^ >p.then(() => null, () => null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => null : () => null @@ -1660,12 +1660,12 @@ const p86 = p.then(() => null, () => {}); > : ^^^^^^^^^^^^^^^^^^^^ >p.then(() => null, () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => {} : () => void @@ -1676,12 +1676,12 @@ const p87 = p.then(() => null, () => {throw 1}); > : ^^^^^^^^^^^^^ >p.then(() => null, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => {throw 1} : () => never @@ -1694,12 +1694,12 @@ const p88 = p.then(() => null, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => null, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => Promise.resolve(1) : () => Promise @@ -1720,12 +1720,12 @@ const p89 = p.then(() => null, () => Promise.reject(1)); > : ^^^^^^^^^^^^^ >p.then(() => null, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => Promise.reject(1) : () => Promise @@ -1746,12 +1746,12 @@ const p90 = p.then(() => {}, undefined); > : ^^^^^^^^^^^^^ >p.then(() => {}, undefined) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >undefined : undefined @@ -1762,12 +1762,12 @@ const p91 = p.then(() => {}, null); > : ^^^^^^^^^^^^^ >p.then(() => {}, null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -1776,12 +1776,12 @@ const p92 = p.then(() => {}, () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => {}, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => 1 : () => number @@ -1794,12 +1794,12 @@ const p93 = p.then(() => {}, () => x); > : ^^^^^^^^^^^^ >p.then(() => {}, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => x : () => any @@ -1811,12 +1811,12 @@ const p94 = p.then(() => {}, () => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => {}, () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => undefined : () => undefined @@ -1829,12 +1829,12 @@ const p95 = p.then(() => {}, () => null); > : ^^^^^^^^^^^^^^^^^^^^ >p.then(() => {}, () => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => null : () => null @@ -1845,12 +1845,12 @@ const p96 = p.then(() => {}, () => {}); > : ^^^^^^^^^^^^^ >p.then(() => {}, () => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => {} : () => void @@ -1861,12 +1861,12 @@ const p97 = p.then(() => {}, () => {throw 1}); > : ^^^^^^^^^^^^^ >p.then(() => {}, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => {throw 1} : () => never @@ -1879,12 +1879,12 @@ const p98 = p.then(() => {}, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => {}, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => Promise.resolve(1) : () => Promise @@ -1905,12 +1905,12 @@ const p99 = p.then(() => {}, () => Promise.reject(1)); > : ^^^^^^^^^^^^^ >p.then(() => {}, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => Promise.reject(1) : () => Promise @@ -1931,12 +1931,12 @@ const pa0 = p.then(() => {throw 1}, undefined); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, undefined) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -1949,12 +1949,12 @@ const pa1 = p.then(() => {throw 1}, null); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, null) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -1965,12 +1965,12 @@ const pa2 = p.then(() => {throw 1}, () => 1); > : ^^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => 1) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -1985,12 +1985,12 @@ const pa3 = p.then(() => {throw 1}, () => x); > : ^^^^^^^^^^^^ >p.then(() => {throw 1}, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2004,12 +2004,12 @@ const pa4 = p.then(() => {throw 1}, () => undefined); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2024,12 +2024,12 @@ const pa5 = p.then(() => {throw 1}, () => null); > : ^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2042,12 +2042,12 @@ const pa6 = p.then(() => {throw 1}, () => {}); > : ^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2060,12 +2060,12 @@ const pa7 = p.then(() => {throw 1}, () => {throw 1}); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2080,12 +2080,12 @@ const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2108,12 +2108,12 @@ const pa9 = p.then(() => {throw 1}, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2136,12 +2136,12 @@ const pb0 = p.then(() => Promise.resolve("1"), undefined); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), undefined) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2162,12 +2162,12 @@ const pb1 = p.then(() => Promise.resolve("1"), null); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), null) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2186,12 +2186,12 @@ const pb2 = p.then(() => Promise.resolve("1"), () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2214,12 +2214,12 @@ const pb3 = p.then(() => Promise.resolve("1"), () => x); > : ^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2241,12 +2241,12 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2269,12 +2269,12 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2295,12 +2295,12 @@ const pb6 = p.then(() => Promise.resolve("1"), () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2321,12 +2321,12 @@ const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1}); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2349,12 +2349,12 @@ const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2385,12 +2385,12 @@ const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2421,12 +2421,12 @@ const pc0 = p.then(() => Promise.reject("1"), undefined); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), undefined) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2447,12 +2447,12 @@ const pc1 = p.then(() => Promise.reject("1"), null); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), null) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2471,12 +2471,12 @@ const pc2 = p.then(() => Promise.reject("1"), () => 1); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => 1) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2499,12 +2499,12 @@ const pc3 = p.then(() => Promise.reject("1"), () => x); > : ^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2526,12 +2526,12 @@ const pc4 = p.then(() => Promise.reject("1"), () => undefined); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2554,12 +2554,12 @@ const pc5 = p.then(() => Promise.reject("1"), () => null); > : ^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2580,12 +2580,12 @@ const pc6 = p.then(() => Promise.reject("1"), () => {}); > : ^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2606,12 +2606,12 @@ const pc7 = p.then(() => Promise.reject("1"), () => {throw 1}); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2634,12 +2634,12 @@ const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2670,12 +2670,12 @@ const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1)); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise diff --git a/tests/baselines/reference/promiseVoidErrorCallback.types b/tests/baselines/reference/promiseVoidErrorCallback.types index 8e7b4e4b28fb3..f2fe0329e362f 100644 --- a/tests/baselines/reference/promiseVoidErrorCallback.types +++ b/tests/baselines/reference/promiseVoidErrorCallback.types @@ -68,20 +68,20 @@ var x3 = f1() > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ >f1() .then(f2, (e: Error) => { throw e;}) .then((x: T2) => { return { __t3: x.__t2 + "bar" };}) : Promise<{ __t3: string; }> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->f1() .then(f2, (e: Error) => { throw e;}) .then : (onfulfilled?: (value: T2) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>f1() .then(f2, (e: Error) => { throw e;}) .then : (deferred onfulfilled?: (value: T2) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >f1() .then(f2, (e: Error) => { throw e;}) : Promise > : ^^^^^^^^^^^ ->f1() .then : (onfulfilled?: (value: T1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>f1() .then : (deferred onfulfilled?: (value: T1) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >f1() : Promise > : ^^^^^^^^^^^ >f1 : () => Promise > : ^^^^^^ .then(f2, (e: Error) => { ->then : (onfulfilled?: (value: T1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: T1) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >f2 : (x: T1) => T2 > : ^ ^^ ^^^^^ >(e: Error) => { throw e;} : (e: Error) => never @@ -95,8 +95,8 @@ var x3 = f1() }) .then((x: T2) => { ->then : (onfulfilled?: (value: T2) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: T2) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >(x: T2) => { return { __t3: x.__t2 + "bar" };} : (x: T2) => { __t3: string; } > : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ >x : T2 diff --git a/tests/baselines/reference/promises.types b/tests/baselines/reference/promises.types index a6dc5831f889f..ec07d93df823b 100644 --- a/tests/baselines/reference/promises.types +++ b/tests/baselines/reference/promises.types @@ -3,16 +3,16 @@ === promises.ts === interface Promise { then(success?: (value: T) => U): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => U): Promise; (success?: (value: T) => Promise): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => U): Promise; (success?: (value: T) => Promise): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => U > : ^ ^^ ^^^^^ >value : T > : ^ then(success?: (value: T) => Promise): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => U_1): Promise; (success?: (value: T) => Promise): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => U_1): Promise; (success?: (value: T) => Promise): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => Promise > : ^ ^^ ^^^^^ >value : T diff --git a/tests/baselines/reference/promisesWithConstraints.types b/tests/baselines/reference/promisesWithConstraints.types index 2ea111f3c24e2..aa219e8ddc799 100644 --- a/tests/baselines/reference/promisesWithConstraints.types +++ b/tests/baselines/reference/promisesWithConstraints.types @@ -3,8 +3,8 @@ === promisesWithConstraints.ts === interface Promise { then(cb: (x: T) => Promise): Promise; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (cb: (x: T) => Promise): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (cb: (x: T) => Promise): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ >cb : (x: T) => Promise > : ^ ^^ ^^^^^ >x : T diff --git a/tests/baselines/reference/specializationError.types b/tests/baselines/reference/specializationError.types index 1ec5f160b60df..fe2e0000ce9aa 100644 --- a/tests/baselines/reference/specializationError.types +++ b/tests/baselines/reference/specializationError.types @@ -3,8 +3,8 @@ === specializationError.ts === interface Promise { then(value: T): void; ->then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (value: T): void; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^^^^ ^^ ^^^ ^^^ +>then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (value: T): void; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^^^^ ^^ ^^^ ^^^ >value : T > : ^ } diff --git a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types index 4210b351073ce..65ed5f799411a 100644 --- a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types +++ b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types @@ -15,14 +15,14 @@ export = packageExport; import("package").then(({default: foo}) => foo(42)); >import("package").then(({default: foo}) => foo(42)) : Promise > : ^^^^^^^^^^^^^^^ ->import("package").then : string; }, TResult2 = never>(onfulfilled?: (value: { default: (x: number) => string; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>import("package").then : string; }, TResult2 = never>(deferred onfulfilled?: (value: { default: (x: number) => string; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >import("package") : Promise<{ default: (x: number) => string; }> > : ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^ >"package" : "package" > : ^^^^^^^^^ ->then : string; }, TResult2 = never>(onfulfilled?: (value: { default: (x: number) => string; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : string; }, TResult2 = never>(deferred onfulfilled?: (value: { default: (x: number) => string; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >({default: foo}) => foo(42) : ({ default: foo }: { default: (x: number) => string; }) => string > : ^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^ >default : any diff --git a/tests/baselines/reference/truthinessPromiseCoercion.types b/tests/baselines/reference/truthinessPromiseCoercion.types index eecd340d61b70..0b66367e07799 100644 --- a/tests/baselines/reference/truthinessPromiseCoercion.types +++ b/tests/baselines/reference/truthinessPromiseCoercion.types @@ -118,12 +118,12 @@ async function g() { > : ^^^^^^^^^^^^^^^ >p.then.length : number > : ^^^^^^ ->p.then : (onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>p.then : (deferred onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^ ->then : (onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >length : number > : ^^^^^^ @@ -239,14 +239,14 @@ async function i(): Promise { pf().then(); >pf().then() : Promise > : ^^^^^^^^^^^^^^^^ ->pf().then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>pf().then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ >pf() : Promise > : ^^^^^^^^^^^^^^^^ >pf : () => Promise > : ^^^^^^ ->then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ } return "false"; >"false" : "false" diff --git a/tests/baselines/reference/unionAndIntersectionInference1.types b/tests/baselines/reference/unionAndIntersectionInference1.types index 73d4c2e8baf5f..bf37559eb9e8c 100644 --- a/tests/baselines/reference/unionAndIntersectionInference1.types +++ b/tests/baselines/reference/unionAndIntersectionInference1.types @@ -283,8 +283,8 @@ const createTestAsync = (): Promise => Promise.resolve().then(() => ({ na > : ^^^^^^ >Promise.resolve().then(() => ({ name: 'test' })) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->Promise.resolve().then : (onfulfilled?: (value: void) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>Promise.resolve().then : (deferred onfulfilled?: (value: void) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >Promise.resolve() : Promise > : ^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -293,8 +293,8 @@ const createTestAsync = (): Promise => Promise.resolve().then(() => ({ na > : ^^^^^^^^^^^^^^^^^^ >resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } > : ^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ->then : (onfulfilled?: (value: void) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ +>then : (deferred onfulfilled?: (value: void) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^ ^^^^^^^^ >() => ({ name: 'test' }) : () => { name: "test"; } > : ^^^^^^^^^^^^^^^^^^^^^^^ >({ name: 'test' }) : { name: "test"; } diff --git a/tests/baselines/reference/unionOfClassCalls.types b/tests/baselines/reference/unionOfClassCalls.types index f49f576b5f0fc..d47ada14b9dfd 100644 --- a/tests/baselines/reference/unionOfClassCalls.types +++ b/tests/baselines/reference/unionOfClassCalls.types @@ -322,8 +322,8 @@ declare var a: Bar | Baz; a.doThing().then((result: Bar | Baz) => { >a.doThing().then((result: Bar | Baz) => { // whatever}) : Promise > : ^^^^^^^^^^^^^ ->a.doThing().then : ((onfulfilled?: ((value: Baz) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) | ((onfulfilled?: ((value: Bar) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^ +>a.doThing().then : ((deferred onfulfilled?: ((value: Baz) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) | ((deferred onfulfilled?: ((value: Bar) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^ >a.doThing() : Promise | Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >a.doThing : (() => Promise) | (() => Promise) @@ -332,8 +332,8 @@ a.doThing().then((result: Bar | Baz) => { > : ^^^^^^^^^ >doThing : (() => Promise) | (() => Promise) > : ^^^^^^^ ^^^ ^^^^^^^^^^^ ^^^ ^ ->then : ((onfulfilled?: ((value: Baz) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) | ((onfulfilled?: ((value: Bar) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^ +>then : ((deferred onfulfilled?: ((value: Baz) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) | ((deferred onfulfilled?: ((value: Bar) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^ >(result: Bar | Baz) => { // whatever} : (result: Bar | Baz) => void > : ^ ^^ ^^^^^^^^^ >result : Bar | Baz diff --git a/tests/baselines/reference/usePromiseFinally.types b/tests/baselines/reference/usePromiseFinally.types index d592af2a378b9..da33ad5de2370 100644 --- a/tests/baselines/reference/usePromiseFinally.types +++ b/tests/baselines/reference/usePromiseFinally.types @@ -6,8 +6,8 @@ let promise1 = new Promise(function(resolve, reject) {}) > : ^^^^^^^^^^^^^^^^ >new Promise(function(resolve, reject) {}) .finally(function() {}) : Promise > : ^^^^^^^^^^^^^^^^ ->new Promise(function(resolve, reject) {}) .finally : (onfinally?: () => void) => Promise -> : ^ ^^^^^^^^^ ^^^^^ ^^^^^^^ +>new Promise(function(resolve, reject) {}) .finally : (deferred onfinally?: () => void) => Promise +> : ^ ^ ^^^^^^^^^ ^^^^^ ^^^^^^^ >new Promise(function(resolve, reject) {}) : Promise > : ^^^^^^^^^^^^^^^^ >Promise : PromiseConstructor @@ -20,8 +20,8 @@ let promise1 = new Promise(function(resolve, reject) {}) > : ^ ^^^ ^^^^^ .finally(function() {}); ->finally : (onfinally?: () => void) => Promise -> : ^ ^^^^^^^^^ ^^^^^ ^^^^^^^ +>finally : (deferred onfinally?: () => void) => Promise +> : ^ ^ ^^^^^^^^^ ^^^^^ ^^^^^^^ >function() {} : () => void > : ^^^^^^^^^^ From 96e692174de24cae914d4ce930186db34630a7e7 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 11 Jul 2024 15:12:03 -0700 Subject: [PATCH 19/30] Support /** @deferred */ in .ts files --- src/compiler/checker.ts | 6 ++-- src/compiler/factory/nodeFactory.ts | 2 +- src/compiler/scanner.ts | 4 +-- src/compiler/types.ts | 46 ++++++++++++++--------------- src/compiler/utilities.ts | 6 ++-- 5 files changed, 32 insertions(+), 32 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 3367fd72a172a..a76eda019f6dd 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -7581,7 +7581,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const parameterType = getTypeOfSymbol(parameterSymbol); const parameterTypeNode = serializeTypeForDeclaration(context, parameterDeclaration, parameterType, parameterSymbol); - const modifiers = parameterDeclaration && canHaveModifiers(parameterDeclaration) && (!(context.flags & NodeBuilderFlags.OmitParameterModifiers) && preserveModifierFlags || hasSyntacticModifier(parameterDeclaration, ModifierFlags.Deferred)) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : undefined; + const modifiers = !(context.flags & NodeBuilderFlags.OmitParameterModifiers) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : undefined; const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & CheckFlags.RestParameter; const dotDotDotToken = isRest ? factory.createToken(SyntaxKind.DotDotDotToken) : undefined; const name = parameterToParameterDeclarationName(parameterSymbol, parameterDeclaration, context); @@ -28452,7 +28452,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // circularities. Instead, we simply check if any signature has a deferred callback marker in the // particular argument position. signatures ??= getSignaturesOfType(getTypeOfExpression(flow.node.expression), SignatureKind.Call); - if (!some(signatures, sig => !!(getModifiersAtPosition(sig, i) & ModifierFlags.Deferred))) { + if (!some(signatures, sig => !!(getModifiersAtPosition(sig, i) & (ModifierFlags.Deferred | ModifierFlags.JSDocDeferred)))) { const lambdaType = getTypeFromFlowType(getTypeAtFlowNode(lambda.returnFlowNode)); if (lambdaType !== initialType) { lambdaTypes ??= [initialType]; @@ -40888,7 +40888,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (node.dotDotDotToken && !isBindingPattern(node.name) && !isTypeAssignableTo(getReducedType(getTypeOfSymbol(node.symbol)), anyReadonlyArrayType)) { error(node, Diagnostics.A_rest_parameter_must_be_of_an_array_type); } - if (hasSyntacticModifier(node, ModifierFlags.Deferred)) { + if (hasEffectiveModifier(node, (ModifierFlags.Deferred | ModifierFlags.JSDocDeferred))) { const funcType = node.dotDotDotToken ? createArrayType(globalFunctionType, /*readonly*/ true) : globalFunctionType; if (!areTypesComparable(getTypeOfSymbol(node.symbol), funcType)) { error(node, Diagnostics.A_deferred_parameter_must_have_a_type_that_permits_functions); diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts index eaba50506b8e6..06ca7e860e764 100644 --- a/src/compiler/factory/nodeFactory.ts +++ b/src/compiler/factory/nodeFactory.ts @@ -1563,6 +1563,7 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode if (flags & ModifierFlags.Ambient) result.push(createModifier(SyntaxKind.DeclareKeyword)); if (flags & ModifierFlags.Default) result.push(createModifier(SyntaxKind.DefaultKeyword)); if (flags & ModifierFlags.Const) result.push(createModifier(SyntaxKind.ConstKeyword)); + if (flags & ModifierFlags.Deferred) result.push(createModifier(SyntaxKind.DeferredKeyword)); if (flags & ModifierFlags.Public) result.push(createModifier(SyntaxKind.PublicKeyword)); if (flags & ModifierFlags.Private) result.push(createModifier(SyntaxKind.PrivateKeyword)); if (flags & ModifierFlags.Protected) result.push(createModifier(SyntaxKind.ProtectedKeyword)); @@ -1574,7 +1575,6 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode if (flags & ModifierFlags.Async) result.push(createModifier(SyntaxKind.AsyncKeyword)); if (flags & ModifierFlags.In) result.push(createModifier(SyntaxKind.InKeyword)); if (flags & ModifierFlags.Out) result.push(createModifier(SyntaxKind.OutKeyword)); - if (flags & ModifierFlags.Deferred) result.push(createModifier(SyntaxKind.DeferredKeyword)); return result.length ? result : undefined; } diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index b211a55f167e3..7f7b6af0e8b31 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -350,7 +350,7 @@ const commentDirectiveRegExSingleLine = /^\/\/\/?\s*@(ts-expect-error|ts-ignore) */ const commentDirectiveRegExMultiLine = /^(?:\/|\*)*\s*@(ts-expect-error|ts-ignore)/; -const jsDocSeeOrLink = /@(?:see|link)/i; +const jsDocSeeOrLinkOrDeferred = /@(?:see|link|deferred)/i; function lookupInUnicodeMap(code: number, map: readonly number[]): boolean { // Bail out quickly if it couldn't possibly be in the map. @@ -2387,7 +2387,7 @@ export function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean return false; } - return jsDocSeeOrLink.test(text.slice(fullStartPos, pos)); + return jsDocSeeOrLinkOrDeferred.test(text.slice(fullStartPos, pos)); } function reScanInvalidIdentifier(): SyntaxKind { diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 91312f5934f8a..bcdfdc4f9680c 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -856,37 +856,37 @@ export const enum ModifierFlags { Protected = 1 << 2, // Property/Method Readonly = 1 << 3, // Property/Method Override = 1 << 4, // Override method. - Deferred = 1 << 5, // Parameter // Syntactic-only modifiers - Export = 1 << 6, // Declarations - Abstract = 1 << 7, // Class/Method/ConstructSignature - Ambient = 1 << 8, // Declarations - Static = 1 << 9, // Property/Method - Accessor = 1 << 10, // Property - Async = 1 << 11, // Property/Method/Function - Default = 1 << 12, // Function/Class (export default declaration) - Const = 1 << 13, // Const enum - In = 1 << 14, // Contravariance modifier - Out = 1 << 15, // Covariance modifier - Decorator = 1 << 16, // Contains a decorator. + Export = 1 << 5, // Declarations + Abstract = 1 << 6, // Class/Method/ConstructSignature + Ambient = 1 << 7, // Declarations + Static = 1 << 8, // Property/Method + Accessor = 1 << 9, // Property + Async = 1 << 10, // Property/Method/Function + Default = 1 << 11, // Function/Class (export default declaration) + Const = 1 << 12, // Const enum + In = 1 << 13, // Contravariance modifier + Out = 1 << 14, // Covariance modifier + Decorator = 1 << 15, // Contains a decorator. + Deferred = 1 << 16, // Parameter // JSDoc-only modifiers Deprecated = 1 << 17, // Deprecated tag. + JSDocDeferred = 1 << 18, // Parameter // Cache-only JSDoc-modifiers. Should match order of Syntactic/JSDoc modifiers, above. - /** @internal */ JSDocPublic = 1 << 22, // if this value changes, `selectEffectiveModifierFlags` must change accordingly - /** @internal */ JSDocPrivate = 1 << 23, - /** @internal */ JSDocProtected = 1 << 24, - /** @internal */ JSDocReadonly = 1 << 25, - /** @internal */ JSDocOverride = 1 << 26, - /** @internal */ JSDocDeferred = 1 << 27, - - /** @internal */ SyntacticOrJSDocModifiers = Public | Private | Protected | Readonly | Override | Deferred, - /** @internal */ SyntacticOnlyModifiers = Export | Ambient | Abstract | Static | Accessor | Async | Default | Const | In | Out | Decorator, + /** @internal */ JSDocPublic = 1 << 23, // if this value changes, `selectEffectiveModifierFlags` must change accordingly + /** @internal */ JSDocPrivate = 1 << 24, + /** @internal */ JSDocProtected = 1 << 25, + /** @internal */ JSDocReadonly = 1 << 26, + /** @internal */ JSDocOverride = 1 << 27, + + /** @internal */ SyntacticOrJSDocModifiers = Public | Private | Protected | Readonly | Override, + /** @internal */ SyntacticOnlyModifiers = Export | Ambient | Abstract | Static | Accessor | Async | Default | Const | In | Out | Decorator | Deferred, /** @internal */ SyntacticModifiers = SyntacticOrJSDocModifiers | SyntacticOnlyModifiers, - /** @internal */ JSDocCacheOnlyModifiers = JSDocPublic | JSDocPrivate | JSDocProtected | JSDocReadonly | JSDocOverride | JSDocDeferred, - /** @internal */ JSDocOnlyModifiers = Deprecated, + /** @internal */ JSDocCacheOnlyModifiers = JSDocPublic | JSDocPrivate | JSDocProtected | JSDocReadonly | JSDocOverride, + /** @internal */ JSDocOnlyModifiers = Deprecated | JSDocDeferred, /** @internal */ NonCacheOnlyModifiers = SyntacticOrJSDocModifiers | SyntacticOnlyModifiers | JSDocOnlyModifiers, HasComputedJSDocModifiers = 1 << 28, // Indicates the computed modifier flags include modifiers from JSDoc. diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 2612c0bfba9b1..7f511172758cd 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -6992,7 +6992,7 @@ function getModifierFlagsWorker(node: Node, includeJSDoc: boolean, alwaysInclude node.modifierFlagsCache = getSyntacticModifierFlagsNoCache(node) | ModifierFlags.HasComputedFlags; } - if (alwaysIncludeJSDoc || includeJSDoc && isInJSFile(node)) { + if (alwaysIncludeJSDoc || includeJSDoc && (isInJSFile(node) || isParameter(node) && node.jsDoc)) { if (!(node.modifierFlagsCache & ModifierFlags.HasComputedJSDocModifiers) && node.parent) { node.modifierFlagsCache |= getRawJSDocModifierFlagsNoCache(node) | ModifierFlags.HasComputedJSDocModifiers; } @@ -7040,9 +7040,9 @@ function getRawJSDocModifierFlagsNoCache(node: Node): ModifierFlags { if (getJSDocReadonlyTagNoCache(node)) flags |= ModifierFlags.JSDocReadonly; if (getJSDocOverrideTagNoCache(node)) flags |= ModifierFlags.JSDocOverride; } - if (getJSDocDeferredTagNoCache(node)) flags |= ModifierFlags.JSDocDeferred; } if (!isParameter(node) && getJSDocDeprecatedTagNoCache(node)) flags |= ModifierFlags.Deprecated; + if (getJSDocDeferredTagNoCache(node)) flags |= ModifierFlags.JSDocDeferred; } return flags; @@ -7054,7 +7054,7 @@ function selectSyntacticModifierFlags(flags: ModifierFlags) { function selectEffectiveModifierFlags(flags: ModifierFlags) { return (flags & ModifierFlags.NonCacheOnlyModifiers) | - ((flags & ModifierFlags.JSDocCacheOnlyModifiers) >>> 22); // shift ModifierFlags.JSDoc* to match ModifierFlags.* + ((flags & ModifierFlags.JSDocCacheOnlyModifiers) >>> 23); // shift ModifierFlags.JSDoc* to match ModifierFlags.* } function getJSDocModifierFlagsNoCache(node: Node): ModifierFlags { From 37e625893fd4c634965af57311beadca720f0f8d Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 11 Jul 2024 15:12:26 -0700 Subject: [PATCH 20/30] Switch lib.d.ts to use /** @deferred */ --- src/lib/es2018.promise.d.ts | 2 +- src/lib/es5.d.ts | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/lib/es2018.promise.d.ts b/src/lib/es2018.promise.d.ts index 49171882e6623..57b91790615c2 100644 --- a/src/lib/es2018.promise.d.ts +++ b/src/lib/es2018.promise.d.ts @@ -8,5 +8,5 @@ interface Promise { * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). * @returns A Promise for the completion of the callback. */ - finally(deferred onfinally?: (() => void) | undefined | null): Promise; + finally(/** @deferred */ onfinally?: (() => void) | undefined | null): Promise; } diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index 0ed54745a74f4..2fe625db3f9da 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -1516,7 +1516,7 @@ interface PromiseLike { * @param onrejected The callback to execute when the Promise is rejected. * @returns A Promise for the completion of which ever callback is executed. */ - then(deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): PromiseLike; + then(/** @deferred */ onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, /** @deferred */ onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): PromiseLike; } /** @@ -1529,14 +1529,14 @@ interface Promise { * @param onrejected The callback to execute when the Promise is rejected. * @returns A Promise for the completion of which ever callback is executed. */ - then(deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; + then(/** @deferred */ onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, /** @deferred */ onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; /** * Attaches a callback for only the rejection of the Promise. * @param onrejected The callback to execute when the Promise is rejected. * @returns A Promise for the completion of the callback. */ - catch(deferred onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; + catch(/** @deferred */ onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; } /** From 22e9458d9ac56239e954023b09443257859d04f0 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 11 Jul 2024 15:12:39 -0700 Subject: [PATCH 21/30] Accept new baselines --- tests/baselines/reference/api/typescript.d.ts | 31 +- .../asyncYieldStarContextualType.types | 16 +- tests/baselines/reference/awaitedType.types | 8 +- ...TypeAsyncFunctionReturnTypeFromUnion.types | 16 +- ...ionEmitExportAliasVisibiilityMarking.types | 8 +- ...itUsingAlternativeContainingModules1.types | 24 +- ...itUsingAlternativeContainingModules2.types | 24 +- ...destructureOfVariableSameAsShorthand.types | 16 +- .../reference/es2018ObjectAssign.types | 8 +- .../reference/esModuleInteropImportCall.types | 8 +- .../reference/genericFunctionInference1.types | 8 +- ...oTypeDefinition_promiseType.baseline.jsonc | 8 +- .../importCallExpression1ES2020.types | 8 +- .../importCallExpression2ES2020.types | 8 +- .../importCallExpression4ES2020.types | 8 +- .../importCallExpressionES5AMD.types | 8 +- .../importCallExpressionES5CJS.types | 8 +- .../importCallExpressionES5System.types | 8 +- .../importCallExpressionES5UMD.types | 8 +- .../importCallExpressionES6AMD.types | 8 +- .../importCallExpressionES6CJS.types | 8 +- .../importCallExpressionES6System.types | 8 +- .../importCallExpressionES6UMD.types | 8 +- .../importCallExpressionErrorInES2015.types | 8 +- .../importCallExpressionInAMD1.types | 8 +- .../importCallExpressionInAMD2.types | 8 +- .../importCallExpressionInAMD4.types | 16 +- .../importCallExpressionInCJS1.types | 8 +- .../importCallExpressionInCJS3.types | 8 +- .../importCallExpressionInCJS5.types | 16 +- .../importCallExpressionInSystem1.types | 8 +- .../importCallExpressionInSystem2.types | 8 +- .../importCallExpressionInSystem4.types | 16 +- .../importCallExpressionInUMD1.types | 8 +- .../importCallExpressionInUMD2.types | 8 +- .../importCallExpressionInUMD4.types | 16 +- ...tCallExpressionNoModuleKindSpecified.types | 8 +- ...portCallExpressionReturnPromiseOfAny.types | 8 +- ...mportCallExpressionShouldNotGetParen.types | 16 +- ...xpressionSpecifierNotStringTypeError.types | 8 +- .../baselines/reference/inferenceLimit.types | 16 +- .../instantiateContextualTypes.types | 24 +- .../reference/mappedTypesGenericTuples2.types | 8 +- .../modularizeLibrary_Dom.asynciterable.types | 8 +- ...eLibrary_NoErrorDuplicateLibOptions1.types | 8 +- ...eLibrary_NoErrorDuplicateLibOptions2.types | 8 +- ...dularizeLibrary_TargetES5UsingES6Lib.types | 8 +- ...dularizeLibrary_Worker.asynciterable.types | 8 +- .../moduleResolutionWithoutExtension5.types | 8 +- .../moduleResolutionWithoutExtension8.types | 8 +- .../optionalFunctionArgAssignability.types | 4 +- .../reference/privateNameMethodAsync.types | 8 +- .../reference/promisePermutations.errors.txt | 4 +- .../reference/promisePermutations.types | 448 ++++---- .../reference/promisePermutations2.errors.txt | 4 +- .../reference/promisePermutations2.types | 436 ++++---- .../reference/promisePermutations3.errors.txt | 4 +- .../reference/promisePermutations3.types | 448 ++++---- tests/baselines/reference/promiseTest.types | 16 +- tests/baselines/reference/promiseType.types | 976 +++++++++--------- .../reference/promiseTypeStrictNull.types | 976 +++++++++--------- .../reference/promiseVoidErrorCallback.types | 16 +- tests/baselines/reference/promises.types | 8 +- .../reference/promisesWithConstraints.types | 4 +- .../reference/specializationError.types | 4 +- ...eticDefaultExportsWithDynamicImports.types | 8 +- .../reference/truthinessPromiseCoercion.types | 16 +- .../unionAndIntersectionInference1.types | 8 +- .../reference/unionOfClassCalls.types | 8 +- .../reference/usePromiseFinally.types | 8 +- 70 files changed, 1974 insertions(+), 1973 deletions(-) diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index fe397fcbf19fb..c6819951b9c55 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -4214,28 +4214,29 @@ declare namespace ts { Protected = 4, Readonly = 8, Override = 16, - Deferred = 32, - Export = 64, - Abstract = 128, - Ambient = 256, - Static = 512, - Accessor = 1024, - Async = 2048, - Default = 4096, - Const = 8192, - In = 16384, - Out = 32768, - Decorator = 65536, + Export = 32, + Abstract = 64, + Ambient = 128, + Static = 256, + Accessor = 512, + Async = 1024, + Default = 2048, + Const = 4096, + In = 8192, + Out = 16384, + Decorator = 32768, + Deferred = 65536, Deprecated = 131072, + JSDocDeferred = 262144, HasComputedJSDocModifiers = 268435456, HasComputedFlags = 536870912, AccessibilityModifier = 7, ParameterPropertyModifier = 31, NonPublicAccessibilityModifier = 6, - TypeScriptModifier = 57791, - ExportDefault = 4160, + TypeScriptModifier = 94431, + ExportDefault = 2080, All = 262143, - Modifier = 196607, + Modifier = 229375, } enum JsxFlags { None = 0, diff --git a/tests/baselines/reference/asyncYieldStarContextualType.types b/tests/baselines/reference/asyncYieldStarContextualType.types index f9a11417a8e0c..1a74d90e887fe 100644 --- a/tests/baselines/reference/asyncYieldStarContextualType.types +++ b/tests/baselines/reference/asyncYieldStarContextualType.types @@ -65,12 +65,12 @@ async function* f(): AsyncGenerator<"NOT_FOUND_AUTHOR" | "NOT_FOUND_BOOK", BookW > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >authorPromise.then(mapper) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->authorPromise.then : , TResult2 = never>(deferred onfulfilled?: (value: Result) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>authorPromise.then : , TResult2 = never>(onfulfilled?: (value: Result) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >authorPromise : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : , TResult2 = never>(deferred onfulfilled?: (value: Result) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : , TResult2 = never>(onfulfilled?: (value: Result) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >mapper : (result: Result) => Result > : ^ ^^ ^^ ^^^^^ @@ -86,12 +86,12 @@ async function* f(): AsyncGenerator<"NOT_FOUND_AUTHOR" | "NOT_FOUND_BOOK", BookW > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >authorPromise.then(mapper) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->authorPromise.then : , TResult2 = never>(deferred onfulfilled?: (value: Result) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>authorPromise.then : , TResult2 = never>(onfulfilled?: (value: Result) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >authorPromise : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : , TResult2 = never>(deferred onfulfilled?: (value: Result) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : , TResult2 = never>(onfulfilled?: (value: Result) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >mapper : (result: Result) => Result > : ^ ^^ ^^ ^^^^^ diff --git a/tests/baselines/reference/awaitedType.types b/tests/baselines/reference/awaitedType.types index a58b57524d886..a025b532bd444 100644 --- a/tests/baselines/reference/awaitedType.types +++ b/tests/baselines/reference/awaitedType.types @@ -801,8 +801,8 @@ async function mainFindMany() { Promise.all(promises).then((results) => { >Promise.all(promises).then((results) => { const first = results[0] const second = results[1] // error }) : Promise > : ^^^^^^^^^^^^^ ->Promise.all(promises).then : (deferred onfulfilled?: (value: [number]) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>Promise.all(promises).then : (onfulfilled?: (value: [number]) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Promise.all(promises) : Promise<[number]> > : ^^^^^^^^^^^^^^^^^ >Promise.all : { (values: Iterable>): Promise[]>; (values: T): Promise<{ -readonly [P in keyof T]: Awaited; }>; } @@ -813,8 +813,8 @@ async function mainFindMany() { > : ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^ ^^^ >promises : readonly [Promise] > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: [number]) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: [number]) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(results) => { const first = results[0] const second = results[1] // error } : (results: [number]) => void > : ^ ^^^^^^^^^^^^^^^^^^^ >results : [number] diff --git a/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnTypeFromUnion.types b/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnTypeFromUnion.types index e6d1461c676cc..162ab46ae510a 100644 --- a/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnTypeFromUnion.types +++ b/tests/baselines/reference/contextuallyTypeAsyncFunctionReturnTypeFromUnion.types @@ -119,14 +119,14 @@ const cb1: LoadCallback = async () => load().then(m => m); > : ^^^^^^^^^^^^^^^^^^^^^^ >load().then(m => m) : Promise > : ^^^^^^^^^^^^^^^^ ->load().then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>load().then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >load() : Promise > : ^^^^^^^^^^^^^^^^ >load : () => Promise > : ^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >m => m : (m: boolean) => boolean > : ^ ^^^^^^^^^^^^^^^^^^^^^ >m : boolean @@ -151,14 +151,14 @@ const cb3: LoadCallback = () => load().then(m => m); > : ^^^^^^^^^^^^^^^^^^^^^^ >load().then(m => m) : Promise > : ^^^^^^^^^^^^^^^^ ->load().then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>load().then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >load() : Promise > : ^^^^^^^^^^^^^^^^ >load : () => Promise > : ^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >m => m : (m: boolean) => boolean > : ^ ^^^^^^^^^^^^^^^^^^^^^ >m : boolean diff --git a/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types b/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types index ef6acb64cf1b1..c61879e9f1711 100644 --- a/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types +++ b/tests/baselines/reference/declarationEmitExportAliasVisibiilityMarking.types @@ -46,14 +46,14 @@ export let lazyCard = () => import('./Card').then(a => a.default); > : ^^^^^^^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >import('./Card').then(a => a.default) : Promise<(suit: import("Types").Suit, rank: import("Types").Rank) => { suit: import("Types").Suit; rank: import("Types").Rank; }> > : ^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->import('./Card').then : (deferred onfulfilled?: (value: typeof import("Card")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>import('./Card').then : (onfulfilled?: (value: typeof import("Card")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >import('./Card') : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >'./Card' : "./Card" > : ^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("Card")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("Card")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >a => a.default : (a: typeof import("Card")) => (suit: import("Types").Suit, rank: import("Types").Rank) => { suit: import("Types").Suit; rank: import("Types").Rank; } > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^ ^^^^^^ ^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >a : typeof import("Card") diff --git a/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules1.types b/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules1.types index cc01bbd39b1d0..744dd7c4291a3 100644 --- a/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules1.types +++ b/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules1.types @@ -431,16 +431,16 @@ const testApi = { return fetch(baseUrl + 'entries') >fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch((err) => console.log(err)) : Promise > : ^^^^^^^^^^^^ ->fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) : Promise > : ^^^^^^^^^^^^ ->fetch(baseUrl + 'entries') .then((res) => res.json()) .then : (deferred onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>fetch(baseUrl + 'entries') .then((res) => res.json()) .then : (onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >fetch(baseUrl + 'entries') .then((res) => res.json()) : Promise > : ^^^^^^^^^^^^ ->fetch(baseUrl + 'entries') .then : (deferred onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>fetch(baseUrl + 'entries') .then : (onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >fetch(baseUrl + 'entries') : Promise > : ^^^^^^^^^^^^^^^^^ >fetch : (input: RequestInfo | URL, init?: RequestInit) => Promise @@ -453,8 +453,8 @@ const testApi = { > : ^^^^^^^^^ .then((res) => res.json()) ->then : (deferred onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(res) => res.json() : (res: Response) => Promise > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >res : Response @@ -469,8 +469,8 @@ const testApi = { > : ^^^^^^ .then((data) => data.entries) ->then : (deferred onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(data) => data.entries : (data: any) => any > : ^ ^^^^^^^^^^^^^ >data : any @@ -481,8 +481,8 @@ const testApi = { > : ^^^ .catch((err) => console.log(err)) ->catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(err) => console.log(err) : (err: any) => void > : ^ ^^^^^^^^^^^^^^ >err : any diff --git a/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules2.types b/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules2.types index ff1d2fd3b41cc..2d35ec9aec8c9 100644 --- a/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules2.types +++ b/tests/baselines/reference/declarationEmitUsingAlternativeContainingModules2.types @@ -439,16 +439,16 @@ const testApi = { return fetch(baseUrl + 'entries') >fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch((err) => console.log(err)) : Promise > : ^^^^^^^^^^^^ ->fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) .catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >fetch(baseUrl + 'entries') .then((res) => res.json()) .then((data) => data.entries) : Promise > : ^^^^^^^^^^^^ ->fetch(baseUrl + 'entries') .then((res) => res.json()) .then : (deferred onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>fetch(baseUrl + 'entries') .then((res) => res.json()) .then : (onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >fetch(baseUrl + 'entries') .then((res) => res.json()) : Promise > : ^^^^^^^^^^^^ ->fetch(baseUrl + 'entries') .then : (deferred onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>fetch(baseUrl + 'entries') .then : (onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >fetch(baseUrl + 'entries') : Promise > : ^^^^^^^^^^^^^^^^^ >fetch : (input: RequestInfo | URL, init?: RequestInit) => Promise @@ -461,8 +461,8 @@ const testApi = { > : ^^^^^^^^^ .then((res) => res.json()) ->then : (deferred onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: Response) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(res) => res.json() : (res: Response) => Promise > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >res : Response @@ -477,8 +477,8 @@ const testApi = { > : ^^^^^^ .then((data) => data.entries) ->then : (deferred onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: any) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(data) => data.entries : (data: any) => any > : ^ ^^^^^^^^^^^^^ >data : any @@ -489,8 +489,8 @@ const testApi = { > : ^^^ .catch((err) => console.log(err)) ->catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(err) => console.log(err) : (err: any) => void > : ^ ^^^^^^^^^^^^^^ >err : any diff --git a/tests/baselines/reference/destructureOfVariableSameAsShorthand.types b/tests/baselines/reference/destructureOfVariableSameAsShorthand.types index e94de43e28b36..e29e0a383563c 100644 --- a/tests/baselines/reference/destructureOfVariableSameAsShorthand.types +++ b/tests/baselines/reference/destructureOfVariableSameAsShorthand.types @@ -20,14 +20,14 @@ async function main() { get().then((response) => { >get().then((response) => { // body is never const body = response.data; }) : Promise > : ^^^^^^^^^^^^^ ->get().then : , TResult2 = never>(deferred onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>get().then : , TResult2 = never>(onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >get() : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >get : >() => Promise > : ^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : , TResult2 = never>(deferred onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : , TResult2 = never>(onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(response) => { // body is never const body = response.data; } : (response: AxiosResponse) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >response : AxiosResponse @@ -48,14 +48,14 @@ async function main() { get().then(({ data }) => { >get().then(({ data }) => { // data is never }) : Promise > : ^^^^^^^^^^^^^ ->get().then : , TResult2 = never>(deferred onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>get().then : , TResult2 = never>(onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >get() : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >get : >() => Promise > : ^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : , TResult2 = never>(deferred onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : , TResult2 = never>(onfulfilled?: (value: AxiosResponse) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >({ data }) => { // data is never } : ({ data }: AxiosResponse) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >data : never diff --git a/tests/baselines/reference/es2018ObjectAssign.types b/tests/baselines/reference/es2018ObjectAssign.types index 786e2bbf7e061..6740751216557 100644 --- a/tests/baselines/reference/es2018ObjectAssign.types +++ b/tests/baselines/reference/es2018ObjectAssign.types @@ -28,10 +28,10 @@ declare const p: Promise; p.finally(); >p.finally() : Promise > : ^^^^^^^^^^^^^^^ ->p.finally : (deferred onfinally?: () => void) => Promise -> : ^ ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ +>p.finally : (onfinally?: () => void) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^ ->finally : (deferred onfinally?: () => void) => Promise -> : ^ ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ +>finally : (onfinally?: () => void) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ diff --git a/tests/baselines/reference/esModuleInteropImportCall.types b/tests/baselines/reference/esModuleInteropImportCall.types index d094f71d57059..eaf2af09696e6 100644 --- a/tests/baselines/reference/esModuleInteropImportCall.types +++ b/tests/baselines/reference/esModuleInteropImportCall.types @@ -14,14 +14,14 @@ export = foo; import("./foo").then(f => { >import("./foo").then(f => { f.default;}) : Promise > : ^^^^^^^^^^^^^ ->import("./foo").then : void; }, TResult2 = never>(deferred onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>import("./foo").then : void; }, TResult2 = never>(onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >import("./foo") : Promise<{ default: () => void; }> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ >"./foo" : "./foo" > : ^^^^^^^ ->then : void; }, TResult2 = never>(deferred onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : void; }, TResult2 = never>(onfulfilled?: (value: { default: () => void; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >f => { f.default;} : (f: { default: () => void; }) => void > : ^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ >f : { default: () => void; } diff --git a/tests/baselines/reference/genericFunctionInference1.types b/tests/baselines/reference/genericFunctionInference1.types index d638e474bf0e5..e973ef58a7da3 100644 --- a/tests/baselines/reference/genericFunctionInference1.types +++ b/tests/baselines/reference/genericFunctionInference1.types @@ -1421,12 +1421,12 @@ const promise = Promise.resolve(1); promise.then( >promise.then( pipe( x => x + 1, x => x * 2, ),) : Promise > : ^^^^^^^^^^^^^^^ ->promise.then : (deferred onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>promise.then : (onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >promise : Promise > : ^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ pipe( >pipe( x => x + 1, x => x * 2, ) : (x: number) => number diff --git a/tests/baselines/reference/goToTypeDefinition_promiseType.baseline.jsonc b/tests/baselines/reference/goToTypeDefinition_promiseType.baseline.jsonc index 8ff1e53037577..f39b30067fce2 100644 --- a/tests/baselines/reference/goToTypeDefinition_promiseType.baseline.jsonc +++ b/tests/baselines/reference/goToTypeDefinition_promiseType.baseline.jsonc @@ -19,14 +19,14 @@ // * @param onrejected The callback to execute when the Promise is rejected. // * @returns A Promise for the completion of which ever callback is executed. // */ -// then(deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; +// then(/** @deferred */ onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, /** @deferred */ onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; // // /** // * Attaches a callback for only the rejection of the Promise. // * @param onrejected The callback to execute when the Promise is rejected. // * @returns A Promise for the completion of the callback. // */ -// catch(deferred onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; +// catch(/** @deferred */ onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; // }|> // // /** @@ -80,14 +80,14 @@ // * @param onrejected The callback to execute when the Promise is rejected. // * @returns A Promise for the completion of which ever callback is executed. // */ -// then(deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; +// then(/** @deferred */ onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, /** @deferred */ onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; // // /** // * Attaches a callback for only the rejection of the Promise. // * @param onrejected The callback to execute when the Promise is rejected. // * @returns A Promise for the completion of the callback. // */ -// catch(deferred onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; +// catch(/** @deferred */ onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; // }|> // // /** diff --git a/tests/baselines/reference/importCallExpression1ES2020.types b/tests/baselines/reference/importCallExpression1ES2020.types index a77f9995a11e0..3ff1bcaaed336 100644 --- a/tests/baselines/reference/importCallExpression1ES2020.types +++ b/tests/baselines/reference/importCallExpression1ES2020.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpression2ES2020.types b/tests/baselines/reference/importCallExpression2ES2020.types index 39031f1c5a9d4..9ecd73e8e55b9 100644 --- a/tests/baselines/reference/importCallExpression2ES2020.types +++ b/tests/baselines/reference/importCallExpression2ES2020.types @@ -22,12 +22,12 @@ function foo(x: Promise) { x.then(value => { >x.then(value => { let b = new value.B(); b.print(); }) : Promise > : ^^^^^^^^^^^^^ ->x.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>x.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >x : Promise > : ^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >value => { let b = new value.B(); b.print(); } : (value: any) => void > : ^ ^^^^^^^^^^^^^^ >value : any diff --git a/tests/baselines/reference/importCallExpression4ES2020.types b/tests/baselines/reference/importCallExpression4ES2020.types index 73ee886238a97..e1ef783a6dfc7 100644 --- a/tests/baselines/reference/importCallExpression4ES2020.types +++ b/tests/baselines/reference/importCallExpression4ES2020.types @@ -56,16 +56,16 @@ class C { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES5AMD.types b/tests/baselines/reference/importCallExpressionES5AMD.types index be08ac6f4a74d..48f71779df78e 100644 --- a/tests/baselines/reference/importCallExpressionES5AMD.types +++ b/tests/baselines/reference/importCallExpressionES5AMD.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES5CJS.types b/tests/baselines/reference/importCallExpressionES5CJS.types index ab332a0d9a566..ce3f268a559db 100644 --- a/tests/baselines/reference/importCallExpressionES5CJS.types +++ b/tests/baselines/reference/importCallExpressionES5CJS.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES5System.types b/tests/baselines/reference/importCallExpressionES5System.types index 16d24da25255e..5c7e4e511afb0 100644 --- a/tests/baselines/reference/importCallExpressionES5System.types +++ b/tests/baselines/reference/importCallExpressionES5System.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES5UMD.types b/tests/baselines/reference/importCallExpressionES5UMD.types index 9b755322e3e4c..e08c6db4b20e3 100644 --- a/tests/baselines/reference/importCallExpressionES5UMD.types +++ b/tests/baselines/reference/importCallExpressionES5UMD.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES6AMD.types b/tests/baselines/reference/importCallExpressionES6AMD.types index b3fb5db273db5..4611ae282b91b 100644 --- a/tests/baselines/reference/importCallExpressionES6AMD.types +++ b/tests/baselines/reference/importCallExpressionES6AMD.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES6CJS.types b/tests/baselines/reference/importCallExpressionES6CJS.types index dcd69797be7e1..6b9d5a041d492 100644 --- a/tests/baselines/reference/importCallExpressionES6CJS.types +++ b/tests/baselines/reference/importCallExpressionES6CJS.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES6System.types b/tests/baselines/reference/importCallExpressionES6System.types index 59f1d4a8520cc..eea3381a651ff 100644 --- a/tests/baselines/reference/importCallExpressionES6System.types +++ b/tests/baselines/reference/importCallExpressionES6System.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionES6UMD.types b/tests/baselines/reference/importCallExpressionES6UMD.types index f9a4fa87e7c70..22c85a6070b29 100644 --- a/tests/baselines/reference/importCallExpressionES6UMD.types +++ b/tests/baselines/reference/importCallExpressionES6UMD.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionErrorInES2015.types b/tests/baselines/reference/importCallExpressionErrorInES2015.types index 992b44d1b128e..7906be1887e8d 100644 --- a/tests/baselines/reference/importCallExpressionErrorInES2015.types +++ b/tests/baselines/reference/importCallExpressionErrorInES2015.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInAMD1.types b/tests/baselines/reference/importCallExpressionInAMD1.types index e8ead7d8a4e96..30a7ad724c4cd 100644 --- a/tests/baselines/reference/importCallExpressionInAMD1.types +++ b/tests/baselines/reference/importCallExpressionInAMD1.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInAMD2.types b/tests/baselines/reference/importCallExpressionInAMD2.types index 0f21a9c1eaa48..940c187c061dc 100644 --- a/tests/baselines/reference/importCallExpressionInAMD2.types +++ b/tests/baselines/reference/importCallExpressionInAMD2.types @@ -23,12 +23,12 @@ function foo(x: Promise) { x.then(value => { >x.then(value => { let b = new value.B(); b.print(); }) : Promise > : ^^^^^^^^^^^^^ ->x.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>x.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >x : Promise > : ^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >value => { let b = new value.B(); b.print(); } : (value: any) => void > : ^ ^^^^^^^^^^^^^^ >value : any diff --git a/tests/baselines/reference/importCallExpressionInAMD4.types b/tests/baselines/reference/importCallExpressionInAMD4.types index 6e85240fc8435..1f5c390e64b71 100644 --- a/tests/baselines/reference/importCallExpressionInAMD4.types +++ b/tests/baselines/reference/importCallExpressionInAMD4.types @@ -56,16 +56,16 @@ class C { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") @@ -158,16 +158,16 @@ export class D { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInCJS1.types b/tests/baselines/reference/importCallExpressionInCJS1.types index d372dec4c8d4f..938500485610f 100644 --- a/tests/baselines/reference/importCallExpressionInCJS1.types +++ b/tests/baselines/reference/importCallExpressionInCJS1.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInCJS3.types b/tests/baselines/reference/importCallExpressionInCJS3.types index c422cd406ed5d..af654beb5e80b 100644 --- a/tests/baselines/reference/importCallExpressionInCJS3.types +++ b/tests/baselines/reference/importCallExpressionInCJS3.types @@ -23,12 +23,12 @@ function foo(x: Promise) { x.then(value => { >x.then(value => { let b = new value.B(); b.print(); }) : Promise > : ^^^^^^^^^^^^^ ->x.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>x.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >x : Promise > : ^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >value => { let b = new value.B(); b.print(); } : (value: any) => void > : ^ ^^^^^^^^^^^^^^ >value : any diff --git a/tests/baselines/reference/importCallExpressionInCJS5.types b/tests/baselines/reference/importCallExpressionInCJS5.types index 2875576bb2427..3adfbc9c051c9 100644 --- a/tests/baselines/reference/importCallExpressionInCJS5.types +++ b/tests/baselines/reference/importCallExpressionInCJS5.types @@ -56,16 +56,16 @@ class C { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") @@ -158,16 +158,16 @@ export class D { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInSystem1.types b/tests/baselines/reference/importCallExpressionInSystem1.types index 3e509d307c9df..e41c50f7c1a24 100644 --- a/tests/baselines/reference/importCallExpressionInSystem1.types +++ b/tests/baselines/reference/importCallExpressionInSystem1.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInSystem2.types b/tests/baselines/reference/importCallExpressionInSystem2.types index 85009745742a1..2ffd403bec514 100644 --- a/tests/baselines/reference/importCallExpressionInSystem2.types +++ b/tests/baselines/reference/importCallExpressionInSystem2.types @@ -23,12 +23,12 @@ function foo(x: Promise) { x.then(value => { >x.then(value => { let b = new value.B(); b.print(); }) : Promise > : ^^^^^^^^^^^^^ ->x.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>x.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >x : Promise > : ^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >value => { let b = new value.B(); b.print(); } : (value: any) => void > : ^ ^^^^^^^^^^^^^^ >value : any diff --git a/tests/baselines/reference/importCallExpressionInSystem4.types b/tests/baselines/reference/importCallExpressionInSystem4.types index 7e29598adaf3b..cef7710895ee0 100644 --- a/tests/baselines/reference/importCallExpressionInSystem4.types +++ b/tests/baselines/reference/importCallExpressionInSystem4.types @@ -56,16 +56,16 @@ class C { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") @@ -158,16 +158,16 @@ export class D { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInUMD1.types b/tests/baselines/reference/importCallExpressionInUMD1.types index f075b44aa489c..2cf45782d8273 100644 --- a/tests/baselines/reference/importCallExpressionInUMD1.types +++ b/tests/baselines/reference/importCallExpressionInUMD1.types @@ -25,12 +25,12 @@ var p1 = import("./0"); p1.then(zero => { >p1.then(zero => { return zero.foo();}) : Promise > : ^^^^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo();} : (zero: typeof import("0")) => string > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionInUMD2.types b/tests/baselines/reference/importCallExpressionInUMD2.types index c8cc4b1aa17ec..55a9c46617fe4 100644 --- a/tests/baselines/reference/importCallExpressionInUMD2.types +++ b/tests/baselines/reference/importCallExpressionInUMD2.types @@ -23,12 +23,12 @@ function foo(x: Promise) { x.then(value => { >x.then(value => { let b = new value.B(); b.print(); }) : Promise > : ^^^^^^^^^^^^^ ->x.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>x.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >x : Promise > : ^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >value => { let b = new value.B(); b.print(); } : (value: any) => void > : ^ ^^^^^^^^^^^^^^ >value : any diff --git a/tests/baselines/reference/importCallExpressionInUMD4.types b/tests/baselines/reference/importCallExpressionInUMD4.types index de7254a0af5ff..4cb77bf0414a0 100644 --- a/tests/baselines/reference/importCallExpressionInUMD4.types +++ b/tests/baselines/reference/importCallExpressionInUMD4.types @@ -56,16 +56,16 @@ class C { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") @@ -158,16 +158,16 @@ export class D { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types index 34761be935419..ad7279528d5e5 100644 --- a/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types +++ b/tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types @@ -57,16 +57,16 @@ class C { this.myModule.then(Zero => { >this.myModule.then(Zero => { console.log(Zero.foo()); }, async err => { console.log(err); let one = await import("./1"); console.log(one.backup()); }) : Promise > : ^^^^^^^^^^^^^ ->this.myModule.then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>this.myModule.then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this.myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this : this > : ^^^^ >myModule : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: typeof import("0")) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero => { console.log(Zero.foo()); } : (Zero: typeof import("0")) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Zero : typeof import("0") diff --git a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types index 061b49e35a833..2cd909131f93d 100644 --- a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types +++ b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types @@ -109,12 +109,12 @@ const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") as Promise { >p1.then(zero => { return zero.foo(); // ok, zero is any}) : Promise > : ^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo(); // ok, zero is any} : (zero: any) => any > : ^ ^^^^^^^^^^^^^ >zero : any diff --git a/tests/baselines/reference/importCallExpressionShouldNotGetParen.types b/tests/baselines/reference/importCallExpressionShouldNotGetParen.types index e296a85f07721..f99d1d3111e6a 100644 --- a/tests/baselines/reference/importCallExpressionShouldNotGetParen.types +++ b/tests/baselines/reference/importCallExpressionShouldNotGetParen.types @@ -10,16 +10,16 @@ const localeName = "zh-CN"; import(`./locales/${localeName}.js`).then(bar => { >import(`./locales/${localeName}.js`).then(bar => { let x = bar;}) : Promise > : ^^^^^^^^^^^^^ ->import(`./locales/${localeName}.js`).then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>import(`./locales/${localeName}.js`).then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >import(`./locales/${localeName}.js`) : Promise > : ^^^^^^^^^^^^ >`./locales/${localeName}.js` : "./locales/zh-CN.js" > : ^^^^^^^^^^^^^^^^^^^^ >localeName : "zh-CN" > : ^^^^^^^ ->then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >bar => { let x = bar;} : (bar: any) => void > : ^ ^^^^^^^^^^^^^^ >bar : any @@ -33,8 +33,8 @@ import(`./locales/${localeName}.js`).then(bar => { import("./locales/" + localeName + ".js").then(bar => { >import("./locales/" + localeName + ".js").then(bar => { let x = bar;}) : Promise > : ^^^^^^^^^^^^^ ->import("./locales/" + localeName + ".js").then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>import("./locales/" + localeName + ".js").then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >import("./locales/" + localeName + ".js") : Promise > : ^^^^^^^^^^^^ >"./locales/" + localeName + ".js" : string @@ -47,8 +47,8 @@ import("./locales/" + localeName + ".js").then(bar => { > : ^^^^^^^ >".js" : ".js" > : ^^^^^ ->then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >bar => { let x = bar;} : (bar: any) => void > : ^ ^^^^^^^^^^^^^^ >bar : any diff --git a/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types index 274627ab91ef7..0fe8ed184071f 100644 --- a/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types +++ b/tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types @@ -47,12 +47,12 @@ const p2 = import(whatToLoad ? getSpecifier() : "defaulPath") p1.then(zero => { >p1.then(zero => { return zero.foo(); // ok, zero is any}) : Promise > : ^^^^^^^^^^^^ ->p1.then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p1.then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p1 : Promise > : ^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >zero => { return zero.foo(); // ok, zero is any} : (zero: any) => any > : ^ ^^^^^^^^^^^^^ >zero : any diff --git a/tests/baselines/reference/inferenceLimit.types b/tests/baselines/reference/inferenceLimit.types index 385201ea02d27..bb31cbbd3a13a 100644 --- a/tests/baselines/reference/inferenceLimit.types +++ b/tests/baselines/reference/inferenceLimit.types @@ -67,8 +67,8 @@ export class BrokenClass { this.doStuff(order.id) >this.doStuff(order.id) .then((items) => { order.items = items; resolve(order); }) : Promise > : ^^^^^^^^^^^^^ ->this.doStuff(order.id) .then : (deferred onfulfilled?: (value: void) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>this.doStuff(order.id) .then : (onfulfilled?: (value: void) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >this.doStuff(order.id) : Promise > : ^^^^^^^^^^^^^ >this.doStuff : (id: number) => Promise @@ -84,8 +84,8 @@ export class BrokenClass { > : ^^^ .then((items) => { ->then : (deferred onfulfilled?: (value: void) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: void) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(items) => { order.items = items; resolve(order); } : (items: void) => void > : ^ ^^^^^^^^^^^^^^^ >items : void @@ -116,8 +116,8 @@ export class BrokenClass { return Promise.all(result.map(populateItems)) >Promise.all(result.map(populateItems)) .then((orders: Array) => { resolve(orders); }) : Promise > : ^^^^^^^^^^^^^ ->Promise.all(result.map(populateItems)) .then : (deferred onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>Promise.all(result.map(populateItems)) .then : (onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Promise.all(result.map(populateItems)) : Promise > : ^^^^^^^^^^^^^^^^^^ >Promise.all : { (values: Iterable>): Promise[]>; (values: T): Promise<{ -readonly [P in keyof T]: Awaited; }>; } @@ -138,8 +138,8 @@ export class BrokenClass { > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ .then((orders: Array) => { ->then : (deferred onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: unknown[]) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(orders: Array) => { resolve(orders); } : (orders: Array) => void > : ^ ^^ ^^^^^^^^^ >orders : MyModule.MyModel[] diff --git a/tests/baselines/reference/instantiateContextualTypes.types b/tests/baselines/reference/instantiateContextualTypes.types index 9368a6ecc93c6..e51df99d1d857 100644 --- a/tests/baselines/reference/instantiateContextualTypes.types +++ b/tests/baselines/reference/instantiateContextualTypes.types @@ -493,8 +493,8 @@ class Interesting { return Promise.resolve().then(() => { >Promise.resolve().then(() => { if (1 < 2) { return 'SOMETHING'; } return 'ELSE'; }) : Promise<"SOMETHING" | "ELSE"> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->Promise.resolve().then : (deferred onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>Promise.resolve().then : (onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve() : Promise > : ^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -503,8 +503,8 @@ class Interesting { > : ^^^^^^^^^^^^^^^^^^ >resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } > : ^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ->then : (deferred onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => { if (1 < 2) { return 'SOMETHING'; } return 'ELSE'; } : () => "SOMETHING" | "ELSE" > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -535,8 +535,8 @@ class Interesting { return Promise.resolve().then(() => { >Promise.resolve().then(() => { return 'ELSE'; }) : Promise<"SOMETHING" | "ELSE"> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->Promise.resolve().then : (deferred onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>Promise.resolve().then : (onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve() : Promise > : ^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -545,8 +545,8 @@ class Interesting { > : ^^^^^^^^^^^^^^^^^^ >resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } > : ^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ->then : (deferred onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => { return 'ELSE'; } : () => "ELSE" > : ^^^^^^^^^^^^ @@ -565,8 +565,8 @@ class Interesting { return Promise.resolve().then(() => { >Promise.resolve().then(() => { if (1 < 2) { return 'SOMETHING'; } return 'SOMETHING'; }) : Promise<"SOMETHING" | "ELSE"> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->Promise.resolve().then : (deferred onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>Promise.resolve().then : (onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve() : Promise > : ^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -575,8 +575,8 @@ class Interesting { > : ^^^^^^^^^^^^^^^^^^ >resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } > : ^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ->then : (deferred onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: void) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => { if (1 < 2) { return 'SOMETHING'; } return 'SOMETHING'; } : () => "SOMETHING" > : ^^^^^^^^^^^^^^^^^ diff --git a/tests/baselines/reference/mappedTypesGenericTuples2.types b/tests/baselines/reference/mappedTypesGenericTuples2.types index 47b5e15567990..07694eba180f6 100644 --- a/tests/baselines/reference/mappedTypesGenericTuples2.types +++ b/tests/baselines/reference/mappedTypesGenericTuples2.types @@ -10,8 +10,8 @@ declare function getT(): T; Promise.all([getT(), ...getT()]).then((result) => { >Promise.all([getT(), ...getT()]).then((result) => { const head = result[0]; // string const tail = result.slice(1); // any[] tail satisfies string[]; // ok}) : Promise > : ^^^^^^^^^^^^^ ->Promise.all([getT(), ...getT()]).then : (deferred onfulfilled?: ((value: [string, ...any[]]) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>Promise.all([getT(), ...getT()]).then : (onfulfilled?: ((value: [string, ...any[]]) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Promise.all([getT(), ...getT()]) : Promise<[string, ...any[]]> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Promise.all : { (values: Iterable>): Promise[]>; (values: T): Promise<{ -readonly [P in keyof T]: Awaited; }>; } @@ -30,8 +30,8 @@ Promise.all([getT(), ...getT()]).then((result) => { >getT() : any >getT : () => T > : ^ ^^^^^^^ ->then : (deferred onfulfilled?: ((value: [string, ...any[]]) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: [string, ...any[]]) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(result) => { const head = result[0]; // string const tail = result.slice(1); // any[] tail satisfies string[]; // ok} : (result: [string, ...any[]]) => void > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >result : [string, ...any[]] diff --git a/tests/baselines/reference/modularizeLibrary_Dom.asynciterable.types b/tests/baselines/reference/modularizeLibrary_Dom.asynciterable.types index d3b18500c648c..999ee253d4e18 100644 --- a/tests/baselines/reference/modularizeLibrary_Dom.asynciterable.types +++ b/tests/baselines/reference/modularizeLibrary_Dom.asynciterable.types @@ -4,8 +4,8 @@ navigator.storage.getDirectory().then(async directory => { >navigator.storage.getDirectory().then(async directory => { for await (const [key, handle] of directory) { handle.kind; }}) : Promise > : ^^^^^^^^^^^^^ ->navigator.storage.getDirectory().then : (deferred onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>navigator.storage.getDirectory().then : (onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >navigator.storage.getDirectory() : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >navigator.storage.getDirectory : () => Promise @@ -18,8 +18,8 @@ navigator.storage.getDirectory().then(async directory => { > : ^^^^^^^^^^^^^^ >getDirectory : () => Promise > : ^^^^^^ ->then : (deferred onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >async directory => { for await (const [key, handle] of directory) { handle.kind; }} : (directory: FileSystemDirectoryHandle) => Promise > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >directory : FileSystemDirectoryHandle diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types index cc9a1718cf3d3..79250a582cd45 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types @@ -225,14 +225,14 @@ declare var console: any; out().then(() => { >out().then(() => { console.log("Yea!");}) : Promise > : ^^^^^^^^^^^^^ ->out().then : (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>out().then : (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >out() : Promise > : ^^^^^^^^^^^^^^^^ >out : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => { console.log("Yea!");} : () => void > : ^^^^^^^^^^ diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types index 7f7d8d4a4e3ab..55d4b9bcb32fc 100644 --- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types +++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types @@ -225,14 +225,14 @@ declare var console: any; out().then(() => { >out().then(() => { console.log("Yea!");}) : Promise > : ^^^^^^^^^^^^^ ->out().then : (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>out().then : (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >out() : Promise > : ^^^^^^^^^^^^^^^^ >out : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => { console.log("Yea!");} : () => void > : ^^^^^^^^^^ diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types index d0f5aafdadf20..a8e7094e15925 100644 --- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types +++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types @@ -225,14 +225,14 @@ declare var console: any; out().then(() => { >out().then(() => { console.log("Yea!");}) : Promise > : ^^^^^^^^^^^^^ ->out().then : (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>out().then : (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >out() : Promise > : ^^^^^^^^^^^^^^^^ >out : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => { console.log("Yea!");} : () => void > : ^^^^^^^^^^ diff --git a/tests/baselines/reference/modularizeLibrary_Worker.asynciterable.types b/tests/baselines/reference/modularizeLibrary_Worker.asynciterable.types index 295327b458876..3e3e22f19a77a 100644 --- a/tests/baselines/reference/modularizeLibrary_Worker.asynciterable.types +++ b/tests/baselines/reference/modularizeLibrary_Worker.asynciterable.types @@ -4,8 +4,8 @@ navigator.storage.getDirectory().then(async directory => { >navigator.storage.getDirectory().then(async directory => { for await (const [key, handle] of directory) { handle.kind; }}) : Promise > : ^^^^^^^^^^^^^ ->navigator.storage.getDirectory().then : (deferred onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>navigator.storage.getDirectory().then : (onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >navigator.storage.getDirectory() : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >navigator.storage.getDirectory : () => Promise @@ -18,8 +18,8 @@ navigator.storage.getDirectory().then(async directory => { > : ^^^^^^^^^^^^^^ >getDirectory : () => Promise > : ^^^^^^ ->then : (deferred onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: FileSystemDirectoryHandle) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >async directory => { for await (const [key, handle] of directory) { handle.kind; }} : (directory: FileSystemDirectoryHandle) => Promise > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >directory : FileSystemDirectoryHandle diff --git a/tests/baselines/reference/moduleResolutionWithoutExtension5.types b/tests/baselines/reference/moduleResolutionWithoutExtension5.types index 9751443bd284e..50d45cebb23dc 100644 --- a/tests/baselines/reference/moduleResolutionWithoutExtension5.types +++ b/tests/baselines/reference/moduleResolutionWithoutExtension5.types @@ -5,14 +5,14 @@ import("./foo").then(x => x); // should error, ask for extension >import("./foo").then(x => x) : Promise > : ^^^^^^^^^^^^ ->import("./foo").then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>import("./foo").then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >import("./foo") : Promise > : ^^^^^^^^^^^^ >"./foo" : "./foo" > : ^^^^^^^ ->then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >x => x : (x: any) => any > : ^ ^^^^^^^^^^^^^ >x : any diff --git a/tests/baselines/reference/moduleResolutionWithoutExtension8.types b/tests/baselines/reference/moduleResolutionWithoutExtension8.types index 25d7873776214..7e6332877585a 100644 --- a/tests/baselines/reference/moduleResolutionWithoutExtension8.types +++ b/tests/baselines/reference/moduleResolutionWithoutExtension8.types @@ -5,14 +5,14 @@ import("./foo").then(x => x); // should error, ask for extension >import("./foo").then(x => x) : Promise > : ^^^^^^^^^^^^ ->import("./foo").then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>import("./foo").then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >import("./foo") : Promise > : ^^^^^^^^^^^^ >"./foo" : "./foo" > : ^^^^^^^ ->then : (deferred onfulfilled?: (value: any) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: any) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >x => x : (x: any) => any > : ^ ^^^^^^^^^^^^^ >x : any diff --git a/tests/baselines/reference/optionalFunctionArgAssignability.types b/tests/baselines/reference/optionalFunctionArgAssignability.types index b667063d259aa..c7190317bdae9 100644 --- a/tests/baselines/reference/optionalFunctionArgAssignability.types +++ b/tests/baselines/reference/optionalFunctionArgAssignability.types @@ -3,8 +3,8 @@ === optionalFunctionArgAssignability.ts === interface Promise { then(onFulfill?: (value: T) => U, onReject?: (reason: any) => U): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (onFulfill?: (value: T) => U, onReject?: (reason: any) => U): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (onFulfill?: (value: T) => U, onReject?: (reason: any) => U): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >onFulfill : (value: T) => U > : ^ ^^ ^^^^^ >value : T diff --git a/tests/baselines/reference/privateNameMethodAsync.types b/tests/baselines/reference/privateNameMethodAsync.types index 74b29c3292789..5f7f74f19b003 100644 --- a/tests/baselines/reference/privateNameMethodAsync.types +++ b/tests/baselines/reference/privateNameMethodAsync.types @@ -128,8 +128,8 @@ const C = class { new C().foo().then(console.log); >new C().foo().then(console.log) : Promise > : ^^^^^^^^^^^^^ ->new C().foo().then : (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>new C().foo().then : (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >new C().foo() : Promise > : ^^^^^^^^^^^^^^^ >new C().foo : () => Promise @@ -140,8 +140,8 @@ new C().foo().then(console.log); > : ^^^^^^^^ >foo : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >console.log : (...data: any[]) => void > : ^^^^ ^^ ^^^^^ >console : Console diff --git a/tests/baselines/reference/promisePermutations.errors.txt b/tests/baselines/reference/promisePermutations.errors.txt index 86b419bd2aaf7..55ac1623cccbd 100644 --- a/tests/baselines/reference/promisePermutations.errors.txt +++ b/tests/baselines/reference/promisePermutations.errors.txt @@ -140,7 +140,7 @@ promisePermutations.ts(160,21): error TS2769: No overload matches this call. Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => IPromise'. Call signature return types 'Promise' and 'IPromise' are incompatible. The types of 'then' are incompatible between these types. - Type '{ (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. + Type '{ (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. Types of parameters 'onfulfilled' and 'success' are incompatible. Types of parameters 'value' and 'value' are incompatible. Type 'number' is not assignable to type 'string'. @@ -515,7 +515,7 @@ promisePermutations.ts(160,21): error TS2769: No overload matches this call. !!! error TS2769: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => IPromise'. !!! error TS2769: Call signature return types 'Promise' and 'IPromise' are incompatible. !!! error TS2769: The types of 'then' are incompatible between these types. -!!! error TS2769: Type '{ (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. +!!! error TS2769: Type '{ (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. !!! error TS2769: Types of parameters 'onfulfilled' and 'success' are incompatible. !!! error TS2769: Types of parameters 'value' and 'value' are incompatible. !!! error TS2769: Type 'number' is not assignable to type 'string'. diff --git a/tests/baselines/reference/promisePermutations.types b/tests/baselines/reference/promisePermutations.types index f300b9ca7f93d..7901f8bb80b4c 100644 --- a/tests/baselines/reference/promisePermutations.types +++ b/tests/baselines/reference/promisePermutations.types @@ -7,8 +7,8 @@ Instantiation count: 5,000 -> 25,000 === promisePermutations.ts === interface Promise { then(success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => Promise > : ^ ^^ ^^^^^ >value : T @@ -23,8 +23,8 @@ interface Promise { > : ^^^ then(success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => Promise > : ^ ^^ ^^^^^ >value : T @@ -39,8 +39,8 @@ interface Promise { > : ^^^ then(success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => U > : ^ ^^ ^^^^^ >value : T @@ -55,8 +55,8 @@ interface Promise { > : ^^^ then(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => U > : ^ ^^ ^^^^^ >value : T @@ -460,12 +460,12 @@ var s1a = s1.then(testFunction, testFunction, testFunction); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunction, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise @@ -478,12 +478,12 @@ var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP); > : ^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunctionP, testFunctionP) : Promise > : ^^^^^^^^^^^^^^^ ->s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunctionP : () => Promise @@ -496,12 +496,12 @@ var s1c = s1.then(testFunctionP, testFunction, testFunction); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunction : () => IPromise @@ -514,24 +514,24 @@ var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction, > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then(testFunctionP, testFunction, testFunction).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then(testFunctionP, testFunction, testFunction).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise > : ^^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise @@ -604,12 +604,12 @@ var s2a = s2.then(testFunction2, testFunction2, testFunction2); > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -622,12 +622,12 @@ var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P); > : ^^^^^^^^^^^^^ ^^^^ >s2.then(testFunction2P, testFunction2P, testFunction2P) : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2P : () => Promise<{ x: number; }> @@ -640,12 +640,12 @@ var s2c = s2.then(testFunction2P, testFunction2, testFunction2); > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -658,24 +658,24 @@ var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunctio > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then(testFunction2P, testFunction2, testFunction2).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then(testFunction2P, testFunction2, testFunction2).then : { , TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -744,12 +744,12 @@ var s3a = s3.then(testFunction3, testFunction3, testFunction3); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -762,12 +762,12 @@ var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P); > : ^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3P, testFunction3P) : Promise > : ^^^^^^^^^^^^^^^ ->s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3P : (x: number) => Promise @@ -780,12 +780,12 @@ var s3c = s3.then(testFunction3P, testFunction3, testFunction3); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -798,24 +798,24 @@ var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunctio > : ^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : Promise > : ^^^^^^^^^^^^^^^ ->s3.then(testFunction3P, testFunction3, testFunction3).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then(testFunction3P, testFunction3, testFunction3).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -896,12 +896,12 @@ var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error > : ^^^^^^^^^^^^^^^ >s4.then(testFunction4, testFunction4, testFunction4) : Promise > : ^^^^^^^^^^^^^^^ ->s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction4 : (x: number, y?: string) => IPromise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise @@ -914,12 +914,12 @@ var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error > : ^^^^^^^^^^^^^^^ >s4.then(testFunction4P, testFunction4P, testFunction4P) : Promise > : ^^^^^^^^^^^^^^^ ->s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise @@ -932,12 +932,12 @@ var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error > : ^^^^^^^^^^^^^^^ >s4.then(testFunction4P, testFunction4, testFunction4) : Promise > : ^^^^^^^^^^^^^^^ ->s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise @@ -950,24 +950,24 @@ var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, test > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then(sIPromise, testFunction4P, testFunction4).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then(sIPromise, testFunction4P, testFunction4).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4.then(sIPromise, testFunction4P, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise > : ^ ^^ ^^ ^^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise @@ -1036,12 +1036,12 @@ var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error > : ^^^^^^^^^^^^^^^ >s5.then(testFunction5, testFunction5, testFunction5) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise @@ -1054,12 +1054,12 @@ var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error > : ^^^^^^^^^^^^^^^ >s5.then(testFunction5P, testFunction5P, testFunction5P) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise @@ -1072,12 +1072,12 @@ var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error > : ^^^^^^^^^^^^^^^ >s5.then(testFunction5P, testFunction5, testFunction5) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise @@ -1090,24 +1090,24 @@ var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then(sPromise, sPromise, sPromise).then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then(sPromise, sPromise, sPromise).then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1176,12 +1176,12 @@ var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error > : ^^^^^^^^^^^^^^^ >s6.then(testFunction6, testFunction6, testFunction6) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise @@ -1194,12 +1194,12 @@ var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error > : ^^^^^^^^^^^^^^^ >s6.then(testFunction6P, testFunction6P, testFunction6P) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise @@ -1212,12 +1212,12 @@ var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error > : ^^^^^^^^^^^^^^^ >s6.then(testFunction6P, testFunction6, testFunction6) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise @@ -1230,24 +1230,24 @@ var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then(sPromise, sPromise, sPromise).then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then(sPromise, sPromise, sPromise).then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1468,12 +1468,12 @@ var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8, testFunction8, testFunction8) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise @@ -1486,12 +1486,12 @@ var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8P, testFunction8P, testFunction8P) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise @@ -1504,12 +1504,12 @@ var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8P, testFunction8, testFunction8) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise @@ -1522,24 +1522,24 @@ var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s8.then(nIPromise, nIPromise, nIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then(nIPromise, nIPromise, nIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8.then(nIPromise, nIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise @@ -1662,12 +1662,12 @@ var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9, testFunction9, testFunction9) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise @@ -1680,12 +1680,12 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9P, testFunction9P, testFunction9P) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise @@ -1698,12 +1698,12 @@ var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9P, testFunction9, testFunction9) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise @@ -1716,12 +1716,12 @@ var s9d = s9.then(sPromise, sPromise, sPromise); // ok > : ^^^^^^^^^^^^^^^ >s9.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise @@ -1734,12 +1734,12 @@ var s9e = s9.then(nPromise, nPromise, nPromise); // ok > : ^^^^^^^^^^^^^^^ >s9.then(nPromise, nPromise, nPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >nPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >nPromise : (x: any) => Promise @@ -1752,12 +1752,12 @@ var s9f = s9.then(testFunction, sIPromise, nIPromise); // error > : ^^^^^^^^^^^^^^^ >s9.then(testFunction, sIPromise, nIPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >sIPromise : (x: any) => IPromise @@ -1770,24 +1770,24 @@ var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then(testFunction, nIPromise, sIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then(testFunction, nIPromise, sIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9.then(testFunction, nIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1930,12 +1930,12 @@ var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunction10, testFunction10, testFunction10) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise > : ^ ^^ ^^ ^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise @@ -1948,12 +1948,12 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok > : ^^^^^^^^^^^^^^^^ >s10.then(testFunction10P, testFunction10P, testFunction10P) : Promise > : ^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction10P : (cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^^^^ >testFunction10P : (cb: (a: U) => U) => Promise @@ -1966,12 +1966,12 @@ var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok > : ^^^^^^^^^^^^^^^^ >s10.then(testFunction10P, testFunction10, testFunction10) : Promise > : ^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction10P : (cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise @@ -1984,12 +1984,12 @@ var s10d = s10.then(sPromise, sPromise, sPromise); // ok > : ^^^^^^^^^^^^^^^ >s10.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise @@ -2002,12 +2002,12 @@ var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(nIPromise, nPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nPromise : (x: any) => Promise @@ -2020,12 +2020,12 @@ var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error > : ^^^^^^^^^^^^^^^ >s10.then(testFunctionP, sIPromise, nIPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >sIPromise : (x: any) => IPromise @@ -2038,24 +2038,24 @@ var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromis > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then(testFunctionP, nIPromise, sIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then(testFunctionP, nIPromise, sIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10.then(testFunctionP, nIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -2094,12 +2094,12 @@ var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok > : ^^^^^^^^^^^^^^^ >s11.then(testFunction11, testFunction11, testFunction11) : Promise > : ^^^^^^^^^^^^^^^ ->s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } @@ -2112,12 +2112,12 @@ var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error > : ^^^^^^^^^^^^^^^ >s11.then(testFunction11P, testFunction11P, testFunction11P) : Promise > : ^^^^^^^^^^^^^^^ ->s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } @@ -2130,12 +2130,12 @@ var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error > : ^^^^^^^^^^^^^^^ >s11.then(testFunction11P, testFunction11, testFunction11) : Promise > : ^^^^^^^^^^^^^^^ ->s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } diff --git a/tests/baselines/reference/promisePermutations2.errors.txt b/tests/baselines/reference/promisePermutations2.errors.txt index f4bc87a3ef985..87559b404a648 100644 --- a/tests/baselines/reference/promisePermutations2.errors.txt +++ b/tests/baselines/reference/promisePermutations2.errors.txt @@ -98,7 +98,7 @@ promisePermutations2.ts(158,21): error TS2345: Argument of type '{ (x: number): promisePermutations2.ts(159,21): error TS2345: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => IPromise'. Call signature return types 'Promise' and 'IPromise' are incompatible. The types of 'then' are incompatible between these types. - Type '{ (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. + Type '{ (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. Types of parameters 'onfulfilled' and 'success' are incompatible. Types of parameters 'value' and 'value' are incompatible. Type 'number' is not assignable to type 'string'. @@ -410,7 +410,7 @@ promisePermutations2.ts(159,21): error TS2345: Argument of type '{ (x: number): !!! error TS2345: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => IPromise'. !!! error TS2345: Call signature return types 'Promise' and 'IPromise' are incompatible. !!! error TS2345: The types of 'then' are incompatible between these types. -!!! error TS2345: Type '{ (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. +!!! error TS2345: Type '{ (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '{ (success?: (value: string) => IPromise, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => IPromise, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => IPromise, progress?: (progress: any) => void): IPromise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise; }'. !!! error TS2345: Types of parameters 'onfulfilled' and 'success' are incompatible. !!! error TS2345: Types of parameters 'value' and 'value' are incompatible. !!! error TS2345: Type 'number' is not assignable to type 'string'. diff --git a/tests/baselines/reference/promisePermutations2.types b/tests/baselines/reference/promisePermutations2.types index 5010eded4cf7e..dade863dfdb7a 100644 --- a/tests/baselines/reference/promisePermutations2.types +++ b/tests/baselines/reference/promisePermutations2.types @@ -8,8 +8,8 @@ Instantiation count: 2,500 -> 10,000 interface Promise { then(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => U > : ^ ^^ ^^^^^ >value : T @@ -413,12 +413,12 @@ var s1a = s1.then(testFunction, testFunction, testFunction); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunction, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise @@ -431,12 +431,12 @@ var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunctionP, testFunctionP) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunctionP : () => Promise @@ -449,12 +449,12 @@ var s1c = s1.then(testFunctionP, testFunction, testFunction); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunction : () => IPromise @@ -467,24 +467,24 @@ var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction, > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then(testFunctionP, testFunction, testFunction).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then(testFunctionP, testFunction, testFunction).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise > : ^^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise @@ -557,12 +557,12 @@ var s2a = s2.then(testFunction2, testFunction2, testFunction2); > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -575,12 +575,12 @@ var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P); > : ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2P, testFunction2P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2P : () => Promise<{ x: number; }> @@ -593,12 +593,12 @@ var s2c = s2.then(testFunction2P, testFunction2, testFunction2); > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -611,24 +611,24 @@ var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunctio > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then(testFunction2P, testFunction2, testFunction2).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then(testFunction2P, testFunction2, testFunction2).then : { , TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -697,12 +697,12 @@ var s3a = s3.then(testFunction3, testFunction3, testFunction3); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -715,12 +715,12 @@ var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3P, testFunction3P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3P : (x: number) => Promise @@ -733,12 +733,12 @@ var s3c = s3.then(testFunction3P, testFunction3, testFunction3); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -751,24 +751,24 @@ var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunctio > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then(testFunction3P, testFunction3, testFunction3).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then(testFunction3P, testFunction3, testFunction3).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -849,12 +849,12 @@ var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s4.then(testFunction4, testFunction4, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction4 : (x: number, y?: string) => IPromise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise @@ -867,12 +867,12 @@ var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s4.then(testFunction4P, testFunction4P, testFunction4P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise @@ -885,12 +885,12 @@ var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s4.then(testFunction4P, testFunction4, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise @@ -903,24 +903,24 @@ var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, test > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then(sIPromise, testFunction4P, testFunction4).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then(sIPromise, testFunction4P, testFunction4).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4.then(sIPromise, testFunction4P, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise > : ^ ^^ ^^ ^^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise @@ -989,12 +989,12 @@ var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s5.then(testFunction5, testFunction5, testFunction5) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise @@ -1007,12 +1007,12 @@ var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s5.then(testFunction5P, testFunction5P, testFunction5P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise @@ -1025,12 +1025,12 @@ var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s5.then(testFunction5P, testFunction5, testFunction5) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise @@ -1043,24 +1043,24 @@ var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then(sPromise, sPromise, sPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: Promise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then(sPromise, sPromise, sPromise).then : { , TResult2 = never>(onfulfilled?: (value: Promise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5.then(sPromise, sPromise, sPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: Promise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: Promise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1129,12 +1129,12 @@ var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s6.then(testFunction6, testFunction6, testFunction6) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise @@ -1147,12 +1147,12 @@ var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s6.then(testFunction6P, testFunction6P, testFunction6P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise @@ -1165,12 +1165,12 @@ var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s6.then(testFunction6P, testFunction6, testFunction6) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise @@ -1183,24 +1183,24 @@ var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then(sPromise, sPromise, sPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: Promise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then(sPromise, sPromise, sPromise).then : { , TResult2 = never>(onfulfilled?: (value: Promise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6.then(sPromise, sPromise, sPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: Promise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: Promise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: Promise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1421,12 +1421,12 @@ var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8, testFunction8, testFunction8) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise @@ -1439,12 +1439,12 @@ var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8P, testFunction8P, testFunction8P) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise @@ -1457,12 +1457,12 @@ var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8P, testFunction8, testFunction8) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise @@ -1475,24 +1475,24 @@ var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s8.then(nIPromise, nIPromise, nIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then(nIPromise, nIPromise, nIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8.then(nIPromise, nIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise @@ -1615,12 +1615,12 @@ var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9, testFunction9, testFunction9) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise @@ -1633,12 +1633,12 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9P, testFunction9P, testFunction9P) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise @@ -1651,12 +1651,12 @@ var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9P, testFunction9, testFunction9) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise @@ -1669,12 +1669,12 @@ var s9d = s9.then(sPromise, sPromise, sPromise); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s9.then(sPromise, sPromise, sPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise @@ -1687,12 +1687,12 @@ var s9e = s9.then(nPromise, nPromise, nPromise); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s9.then(nPromise, nPromise, nPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >nPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >nPromise : (x: any) => Promise @@ -1705,12 +1705,12 @@ var s9f = s9.then(testFunction, sIPromise, nIPromise); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s9.then(testFunction, sIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >sIPromise : (x: any) => IPromise @@ -1723,24 +1723,24 @@ var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then(testFunction, nIPromise, sIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then(testFunction, nIPromise, sIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9.then(testFunction, nIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1883,12 +1883,12 @@ var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunction10, testFunction10, testFunction10) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise > : ^ ^^ ^^ ^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise @@ -1901,12 +1901,12 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunction10P, testFunction10P, testFunction10P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction10P : (cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^^^^ >testFunction10P : (cb: (a: U) => U) => Promise @@ -1919,12 +1919,12 @@ var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunction10P, testFunction10, testFunction10) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction10P : (cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise @@ -1937,12 +1937,12 @@ var s10d = s10.then(sPromise, sPromise, sPromise); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(sPromise, sPromise, sPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise @@ -1955,12 +1955,12 @@ var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(nIPromise, nPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nPromise : (x: any) => Promise @@ -1973,12 +1973,12 @@ var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunctionP, sIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >sIPromise : (x: any) => IPromise @@ -1991,24 +1991,24 @@ var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromis > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then(testFunctionP, nIPromise, sIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then(testFunctionP, nIPromise, sIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10.then(testFunctionP, nIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -2047,12 +2047,12 @@ var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s11.then(testFunction11, testFunction11, testFunction11) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } @@ -2065,12 +2065,12 @@ var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^ >s11.then(testFunction11P, testFunction11P, testFunction11P) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } @@ -2083,12 +2083,12 @@ var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s11.then(testFunction11P, testFunction11, testFunction11) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } diff --git a/tests/baselines/reference/promisePermutations3.errors.txt b/tests/baselines/reference/promisePermutations3.errors.txt index 7be29477e655d..4b653256db3e7 100644 --- a/tests/baselines/reference/promisePermutations3.errors.txt +++ b/tests/baselines/reference/promisePermutations3.errors.txt @@ -119,7 +119,7 @@ promisePermutations3.ts(159,21): error TS2769: No overload matches this call. Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => IPromise'. Call signature return types 'Promise' and 'IPromise' are incompatible. The types of 'then' are incompatible between these types. - Type '{ (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise'. + Type '{ (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise'. Types of parameters 'onfulfilled' and 'success' are incompatible. Types of parameters 'value' and 'value' are incompatible. Type 'number' is not assignable to type 'string'. @@ -463,7 +463,7 @@ promisePermutations3.ts(165,21): error TS2345: Argument of type '{ (x: T): IP !!! error TS2769: Argument of type '{ (x: number): Promise; (x: string): Promise; }' is not assignable to parameter of type '(value: number) => IPromise'. !!! error TS2769: Call signature return types 'Promise' and 'IPromise' are incompatible. !!! error TS2769: The types of 'then' are incompatible between these types. -!!! error TS2769: Type '{ (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise'. +!!! error TS2769: Type '{ (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; }' is not assignable to type '(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise'. !!! error TS2769: Types of parameters 'onfulfilled' and 'success' are incompatible. !!! error TS2769: Types of parameters 'value' and 'value' are incompatible. !!! error TS2769: Type 'number' is not assignable to type 'string'. diff --git a/tests/baselines/reference/promisePermutations3.types b/tests/baselines/reference/promisePermutations3.types index 8b711bd3f3885..45ceb37d0d281 100644 --- a/tests/baselines/reference/promisePermutations3.types +++ b/tests/baselines/reference/promisePermutations3.types @@ -9,8 +9,8 @@ Instantiation count: 5,000 -> 10,000 interface Promise { then(success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => Promise > : ^ ^^ ^^^^^ >value : T @@ -25,8 +25,8 @@ interface Promise { > : ^^^ then(success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => Promise > : ^ ^^ ^^^^^ >value : T @@ -41,8 +41,8 @@ interface Promise { > : ^^^ then(success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => U > : ^ ^^ ^^^^^ >value : T @@ -57,8 +57,8 @@ interface Promise { > : ^^^ then(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => Promise, error?: (error: any) => U_1, progress?: (progress: any) => void): Promise; (success?: (value: T) => U_1, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => U > : ^ ^^ ^^^^^ >value : T @@ -414,12 +414,12 @@ var s1a = s1.then(testFunction, testFunction, testFunction); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunction, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise @@ -432,12 +432,12 @@ var s1b = s1.then(testFunctionP, testFunctionP, testFunctionP); > : ^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunctionP, testFunctionP) : Promise > : ^^^^^^^^^^^^^^^ ->s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunctionP : () => Promise @@ -450,12 +450,12 @@ var s1c = s1.then(testFunctionP, testFunction, testFunction); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunction : () => IPromise @@ -468,24 +468,24 @@ var s1d = s1.then(testFunctionP, testFunction, testFunction).then(testFunction, > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction).then(testFunction, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then(testFunctionP, testFunction, testFunction).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then(testFunctionP, testFunction, testFunction).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1.then(testFunctionP, testFunction, testFunction) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s1.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s1.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s1 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise > : ^^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >testFunction : () => IPromise @@ -558,12 +558,12 @@ var s2a = s2.then(testFunction2, testFunction2, testFunction2); > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -576,12 +576,12 @@ var s2b = s2.then(testFunction2P, testFunction2P, testFunction2P); > : ^^^^^^^^^^^^^ ^^^^ >s2.then(testFunction2P, testFunction2P, testFunction2P) : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2P : () => Promise<{ x: number; }> @@ -594,12 +594,12 @@ var s2c = s2.then(testFunction2P, testFunction2, testFunction2); > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -612,24 +612,24 @@ var s2d = s2.then(testFunction2P, testFunction2, testFunction2).then(testFunctio > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2).then(testFunction2, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then(testFunction2P, testFunction2, testFunction2).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then(testFunction2P, testFunction2, testFunction2).then : { , TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2.then(testFunction2P, testFunction2, testFunction2) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ->s2.then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s2.then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s2 : Promise<{ x: number; }> > : ^^^^^^^^^^^^^ ^^^^ ->then : { (deferred onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: { x: number; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: { x: number; }) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^ ^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2P : () => Promise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise<{ x: number; }>) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise<{ x: number; }>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> > : ^^^^^^ >testFunction2 : () => IPromise<{ x: number; }> @@ -698,12 +698,12 @@ var s3a = s3.then(testFunction3, testFunction3, testFunction3); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -716,12 +716,12 @@ var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P); > : ^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3P, testFunction3P) : Promise > : ^^^^^^^^^^^^^^^ ->s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3P : (x: number) => Promise @@ -734,12 +734,12 @@ var s3c = s3.then(testFunction3P, testFunction3, testFunction3); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -752,24 +752,24 @@ var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunctio > : ^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3) : Promise > : ^^^^^^^^^^^^^^^ ->s3.then(testFunction3P, testFunction3, testFunction3).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then(testFunction3P, testFunction3, testFunction3).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3.then(testFunction3P, testFunction3, testFunction3) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s3.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s3.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s3 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3P : (x: number) => Promise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction3 : (x: number) => IPromise > : ^ ^^ ^^^^^ >testFunction3 : (x: number) => IPromise @@ -850,12 +850,12 @@ var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error > : ^^^^^^^^^^^^^^^ >s4.then(testFunction4, testFunction4, testFunction4) : Promise > : ^^^^^^^^^^^^^^^ ->s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction4 : (x: number, y?: string) => IPromise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise @@ -868,12 +868,12 @@ var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error > : ^^^^^^^^^^^^^^^ >s4.then(testFunction4P, testFunction4P, testFunction4P) : Promise > : ^^^^^^^^^^^^^^^ ->s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise @@ -886,12 +886,12 @@ var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error > : ^^^^^^^^^^^^^^^ >s4.then(testFunction4P, testFunction4, testFunction4) : Promise > : ^^^^^^^^^^^^^^^ ->s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise @@ -904,24 +904,24 @@ var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, test > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then(sIPromise, testFunction4P, testFunction4).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then(sIPromise, testFunction4P, testFunction4).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4.then(sIPromise, testFunction4P, testFunction4) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s4.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s4.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s4 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise > : ^ ^^ ^^ ^^^ ^^^^^ >testFunction4 : (x: number, y?: string) => IPromise > : ^ ^^ ^^ ^^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >testFunction4P : (x: number, y?: string) => Promise @@ -990,12 +990,12 @@ var s5a = s5.then(testFunction5, testFunction5, testFunction5); // error > : ^^^^^^^^^^^^^^^ >s5.then(testFunction5, testFunction5, testFunction5) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise @@ -1008,12 +1008,12 @@ var s5b = s5.then(testFunction5P, testFunction5P, testFunction5P); // error > : ^^^^^^^^^^^^^^^ >s5.then(testFunction5P, testFunction5P, testFunction5P) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise @@ -1026,12 +1026,12 @@ var s5c = s5.then(testFunction5P, testFunction5, testFunction5); // error > : ^^^^^^^^^^^^^^^ >s5.then(testFunction5P, testFunction5, testFunction5) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction5P : (x: number, cb: (a: string) => string) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction5 : (x: number, cb: (a: string) => string) => IPromise @@ -1044,24 +1044,24 @@ var s5d = s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s5.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s5.then(sPromise, sPromise, sPromise).then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then(sPromise, sPromise, sPromise).then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s5.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s5.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s5 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1130,12 +1130,12 @@ var s6a = s6.then(testFunction6, testFunction6, testFunction6); // error > : ^^^^^^^^^^^^^^^ >s6.then(testFunction6, testFunction6, testFunction6) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise @@ -1148,12 +1148,12 @@ var s6b = s6.then(testFunction6P, testFunction6P, testFunction6P); // error > : ^^^^^^^^^^^^^^^ >s6.then(testFunction6P, testFunction6P, testFunction6P) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise @@ -1166,12 +1166,12 @@ var s6c = s6.then(testFunction6P, testFunction6, testFunction6); // error > : ^^^^^^^^^^^^^^^ >s6.then(testFunction6P, testFunction6, testFunction6) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction6P : (x: number, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^^^^ >testFunction6 : (x: number, cb: (a: T) => T) => IPromise @@ -1184,24 +1184,24 @@ var s6d = s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPro > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s6.then(sPromise, sPromise, sPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s6.then(sPromise, sPromise, sPromise).then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then(sPromise, sPromise, sPromise).then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s6.then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s6.then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s6 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ ->then : { (deferred onfulfilled?: (value: string) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: string) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: string) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1422,12 +1422,12 @@ var s8a = s8.then(testFunction8, testFunction8, testFunction8); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8, testFunction8, testFunction8) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise @@ -1440,12 +1440,12 @@ var s8b = s8.then(testFunction8P, testFunction8P, testFunction8P); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8P, testFunction8P, testFunction8P) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise @@ -1458,12 +1458,12 @@ var s8c = s8.then(testFunction8P, testFunction8, testFunction8); // error > : ^^^^^^^^^^^^^^^^ >s8.then(testFunction8P, testFunction8, testFunction8) : Promise > : ^^^^^^^^^^^^^^^^ ->s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction8P : (x: T, cb: (a: T) => T) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction8 : (x: T, cb: (a: T) => T) => IPromise @@ -1476,24 +1476,24 @@ var s8d = s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nI > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s8.then(nIPromise, nIPromise, nIPromise).then(nIPromise, nIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s8.then(nIPromise, nIPromise, nIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then(nIPromise, nIPromise, nIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8.then(nIPromise, nIPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s8.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s8.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s8 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nIPromise : (x: any) => IPromise @@ -1616,12 +1616,12 @@ var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9, testFunction9, testFunction9) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise @@ -1634,12 +1634,12 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9P, testFunction9P, testFunction9P) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise @@ -1652,12 +1652,12 @@ var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error > : ^^^^^^^^^^^^^^^^ >s9.then(testFunction9P, testFunction9, testFunction9) : Promise > : ^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction9P : (x: T, cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^ ^^ ^^^^^ >testFunction9 : (x: T, cb: (a: U) => U) => IPromise @@ -1670,12 +1670,12 @@ var s9d = s9.then(sPromise, sPromise, sPromise); // ok > : ^^^^^^^^^^^^^^^ >s9.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise @@ -1688,12 +1688,12 @@ var s9e = s9.then(nPromise, nPromise, nPromise); // ok > : ^^^^^^^^^^^^^^^ >s9.then(nPromise, nPromise, nPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >nPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >nPromise : (x: any) => Promise @@ -1706,12 +1706,12 @@ var s9f = s9.then(testFunction, sIPromise, nIPromise); // error > : ^^^^^^^^^^^^^^^ >s9.then(testFunction, sIPromise, nIPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >sIPromise : (x: any) => IPromise @@ -1724,24 +1724,24 @@ var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then(testFunction, nIPromise, sIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then(testFunction, nIPromise, sIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9.then(testFunction, nIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s9.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s9.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s9 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction : () => IPromise > : ^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -1884,12 +1884,12 @@ var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunction10, testFunction10, testFunction10) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise > : ^ ^^ ^^ ^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise @@ -1902,12 +1902,12 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok > : ^^^^^^^^^^^^^^^^ >s10.then(testFunction10P, testFunction10P, testFunction10P) : Promise > : ^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction10P : (cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^^^^ >testFunction10P : (cb: (a: U) => U) => Promise @@ -1920,12 +1920,12 @@ var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok > : ^^^^^^^^^^^^^^^^ >s10.then(testFunction10P, testFunction10, testFunction10) : Promise > : ^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction10P : (cb: (a: U) => U) => Promise > : ^ ^^ ^^ ^^^^^ >testFunction10 : (cb: (a: U) => U) => IPromise @@ -1938,12 +1938,12 @@ var s10d = s10.then(sPromise, sPromise, sPromise); // ok > : ^^^^^^^^^^^^^^^ >s10.then(sPromise, sPromise, sPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sPromise : (x: any) => Promise @@ -1956,12 +1956,12 @@ var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(nIPromise, nPromise, nIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >nPromise : (x: any) => Promise @@ -1974,12 +1974,12 @@ var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error > : ^^^^^^^^^^^^^^^ >s10.then(testFunctionP, sIPromise, nIPromise) : Promise > : ^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >sIPromise : (x: any) => IPromise @@ -1992,24 +1992,24 @@ var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromis > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then(testFunctionP, nIPromise, sIPromise).then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then(testFunctionP, nIPromise, sIPromise).then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10.then(testFunctionP, nIPromise, sIPromise) : Promise> > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->s10.then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s10.then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s10 : Promise > : ^^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: unknown) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: unknown) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: unknown) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunctionP : () => Promise > : ^^^^^^ >nIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise > : ^ ^^ ^^^^^ ->then : { , TResult2 = never>(deferred onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { , TResult2 = never>(onfulfilled?: (value: IPromise) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: IPromise) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >sPromise : (x: any) => Promise > : ^ ^^ ^^^^^ >sIPromise : (x: any) => IPromise @@ -2048,12 +2048,12 @@ var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok > : ^^^^^^^^^^^^^^^ >s11.then(testFunction11, testFunction11, testFunction11) : Promise > : ^^^^^^^^^^^^^^^ ->s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } @@ -2066,12 +2066,12 @@ var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error > : ^^^^^^^^^^^^^^^ >s11.then(testFunction11P, testFunction11P, testFunction11P) : Promise > : ^^^^^^^^^^^^^^^ ->s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } @@ -2084,12 +2084,12 @@ var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error > : ^^^^^^^^^^^^^^^ >s11.then(testFunction11P, testFunction11, testFunction11) : Promise > : ^^^^^^^^^^^^^^^ ->s11.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>s11.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >s11 : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => Promise, error?: (error: any) => U, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => Promise, progress?: (progress: any) => void): Promise; (success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^ >testFunction11P : { (x: number): Promise; (x: string): Promise; } > : ^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ >testFunction11 : { (x: number): IPromise; (x: string): IPromise; } diff --git a/tests/baselines/reference/promiseTest.types b/tests/baselines/reference/promiseTest.types index b356e6196052e..9c341375dfe84 100644 --- a/tests/baselines/reference/promiseTest.types +++ b/tests/baselines/reference/promiseTest.types @@ -3,16 +3,16 @@ === promiseTest.ts === interface Promise { then(success?: (value: T) => Promise): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise): Promise; (success?: (value: T) => B): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise): Promise; (success?: (value: T) => B): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => Promise > : ^ ^^ ^^^^^ >value : T > : ^ then(success?: (value: T) => B): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise): Promise; (success?: (value: T) => B): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => Promise): Promise; (success?: (value: T) => B): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => B > : ^ ^^ ^^^^^ >value : T @@ -32,12 +32,12 @@ var p2 = p.then(function (x) { > : ^^^^^^^^^^^^^^^ >p.then(function (x) { return p;} ) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise): Promise; (success?: (value: number) => B): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise): Promise; (success?: (value: number) => B): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^ ->then : { (deferred onfulfilled?: (value: number) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise): Promise; (success?: (value: number) => B): Promise; } -> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : { (onfulfilled?: (value: number) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike): Promise; (success?: (value: number) => Promise): Promise; (success?: (value: number) => B): Promise; } +> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >function (x) { return p;} : (x: number) => Promise > : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >x : number diff --git a/tests/baselines/reference/promiseType.types b/tests/baselines/reference/promiseType.types index aebab08f9e83b..1a975630f0f52 100644 --- a/tests/baselines/reference/promiseType.types +++ b/tests/baselines/reference/promiseType.types @@ -252,36 +252,36 @@ const p00 = p.catch(); > : ^^^^^^^^^^^^^^^^ >p.catch() : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const p01 = p.then(); >p01 : Promise > : ^^^^^^^^^^^^^^^^ >p.then() : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const p10 = p.catch(undefined); >p10 : Promise > : ^^^^^^^^^^^^^^^^ >p.catch(undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -290,24 +290,24 @@ const p11 = p.catch(null); > : ^^^^^^^^^^^^^^^^ >p.catch(null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const p12 = p.catch(() => 1); >p12 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => 1 : () => number > : ^^^^^^^^^^^^ >1 : 1 @@ -318,12 +318,12 @@ const p13 = p.catch(() => x); > : ^^^^^^^^^^^^ >p.catch(() => x) : Promise > : ^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -333,12 +333,12 @@ const p14 = p.catch(() => undefined); > : ^^^^^^^^^^^^ >p.catch(() => undefined) : Promise > : ^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -349,12 +349,12 @@ const p15 = p.catch(() => null); > : ^^^^^^^^^^^^ >p.catch(() => null) : Promise > : ^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ @@ -363,12 +363,12 @@ const p16 = p.catch(() => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -377,12 +377,12 @@ const p17 = p.catch(() => {throw 1}); > : ^^^^^^^^^^^^^^^^ >p.catch(() => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -393,12 +393,12 @@ const p18 = p.catch(() => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^ >p.catch(() => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject(1) : Promise @@ -417,12 +417,12 @@ const p19 = p.catch(() => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: (reason: any) => TResult | PromiseLike) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: (reason: any) => TResult | PromiseLike) => Promise +> : ^ ^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve(1) : Promise @@ -441,12 +441,12 @@ const p20 = p.then(undefined); > : ^^^^^^^^^^^^^^^^ >p.then(undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -455,24 +455,24 @@ const p21 = p.then(null); > : ^^^^^^^^^^^^^^^^ >p.then(null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const p22 = p.then(() => 1); >p22 : Promise > : ^^^^^^^^^^^^^^^ >p.then(() => 1) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => 1 : () => number > : ^^^^^^^^^^^^ >1 : 1 @@ -483,12 +483,12 @@ const p23 = p.then(() => x); > : ^^^^^^^^^^^^ >p.then(() => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -498,12 +498,12 @@ const p24 = p.then(() => undefined); > : ^^^^^^^^^^^^ >p.then(() => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -514,12 +514,12 @@ const p25 = p.then(() => null); > : ^^^^^^^^^^^^ >p.then(() => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ @@ -528,12 +528,12 @@ const p26 = p.then(() => {}); > : ^^^^^^^^^^^^^ >p.then(() => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -542,12 +542,12 @@ const p27 = p.then(() => {throw 1}); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -558,12 +558,12 @@ const p28 = p.then(() => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve(1) : Promise @@ -582,12 +582,12 @@ const p29 = p.then(() => Promise.reject(1)); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject(1) : Promise @@ -606,12 +606,12 @@ const p30 = p.then(undefined, undefined); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >undefined : undefined @@ -622,12 +622,12 @@ const p31 = p.then(undefined, null); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -636,12 +636,12 @@ const p32 = p.then(undefined, () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => 1 : () => number @@ -654,12 +654,12 @@ const p33 = p.then(undefined, () => x); > : ^^^^^^^^^^^^ >p.then(undefined, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => x : () => any @@ -671,12 +671,12 @@ const p34 = p.then(undefined, () => undefined); > : ^^^^^^^^^^^^ >p.then(undefined, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => undefined : () => any @@ -689,12 +689,12 @@ const p35 = p.then(undefined, () => null); > : ^^^^^^^^^^^^ >p.then(undefined, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => null : () => any @@ -705,12 +705,12 @@ const p36 = p.then(undefined, () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => {} : () => void @@ -721,12 +721,12 @@ const p37 = p.then(undefined, () => {throw 1}); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => {throw 1} : () => never @@ -739,12 +739,12 @@ const p38 = p.then(undefined, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => Promise.resolve(1) : () => Promise @@ -765,12 +765,12 @@ const p39 = p.then(undefined, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => Promise.reject(1) : () => Promise @@ -791,12 +791,12 @@ const p40 = p.then(null, undefined); > : ^^^^^^^^^^^^^^^^ >p.then(null, undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -805,24 +805,24 @@ const p41 = p.then(null, null); > : ^^^^^^^^^^^^^^^^ >p.then(null, null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const p42 = p.then(null, () => 1); >p42 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => 1 : () => number > : ^^^^^^^^^^^^ >1 : 1 @@ -833,12 +833,12 @@ const p43 = p.then(null, () => x); > : ^^^^^^^^^^^^ >p.then(null, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -848,12 +848,12 @@ const p44 = p.then(null, () => undefined); > : ^^^^^^^^^^^^ >p.then(null, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -864,12 +864,12 @@ const p45 = p.then(null, () => null); > : ^^^^^^^^^^^^ >p.then(null, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ @@ -878,12 +878,12 @@ const p46 = p.then(null, () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -892,12 +892,12 @@ const p47 = p.then(null, () => {throw 1}); > : ^^^^^^^^^^^^^^^^ >p.then(null, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -908,12 +908,12 @@ const p48 = p.then(null, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve(1) : Promise @@ -932,12 +932,12 @@ const p49 = p.then(null, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^ >p.then(null, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject(1) : Promise @@ -956,12 +956,12 @@ const p50 = p.then(() => "1", undefined); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", undefined) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -974,12 +974,12 @@ const p51 = p.then(() => "1", null); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", null) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -990,12 +990,12 @@ const p52 = p.then(() => "1", () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1010,12 +1010,12 @@ const p53 = p.then(() => "1", () => x); > : ^^^^^^^^^^^^ >p.then(() => "1", () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1029,12 +1029,12 @@ const p54 = p.then(() => "1", () => undefined); > : ^^^^^^^^^^^^ >p.then(() => "1", () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1049,12 +1049,12 @@ const p55 = p.then(() => "1", () => null); > : ^^^^^^^^^^^^ >p.then(() => "1", () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1067,12 +1067,12 @@ const p56 = p.then(() => "1", () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1085,12 +1085,12 @@ const p57 = p.then(() => "1", () => {throw 1}); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1105,12 +1105,12 @@ const p58 = p.then(() => "1", () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1133,12 +1133,12 @@ const p59 = p.then(() => "1", () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1161,12 +1161,12 @@ const p60 = p.then(() => x, undefined); > : ^^^^^^^^^^^^ >p.then(() => x, undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1178,12 +1178,12 @@ const p61 = p.then(() => x, null); > : ^^^^^^^^^^^^ >p.then(() => x, null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1193,12 +1193,12 @@ const p62 = p.then(() => x, () => 1); > : ^^^^^^^^^^^^ >p.then(() => x, () => 1) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1212,12 +1212,12 @@ const p63 = p.then(() => x, () => x); > : ^^^^^^^^^^^^ >p.then(() => x, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1230,12 +1230,12 @@ const p64 = p.then(() => x, () => undefined); > : ^^^^^^^^^^^^ >p.then(() => x, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1249,12 +1249,12 @@ const p65 = p.then(() => x, () => null); > : ^^^^^^^^^^^^ >p.then(() => x, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1266,12 +1266,12 @@ const p66 = p.then(() => x, () => {}); > : ^^^^^^^^^^^^ >p.then(() => x, () => {}) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1283,12 +1283,12 @@ const p67 = p.then(() => x, () => {throw 1}); > : ^^^^^^^^^^^^ >p.then(() => x, () => {throw 1}) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1302,12 +1302,12 @@ const p68 = p.then(() => x, () => Promise.resolve(1)); > : ^^^^^^^^^^^^ >p.then(() => x, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1329,12 +1329,12 @@ const p69 = p.then(() => x, () => Promise.reject(1)); > : ^^^^^^^^^^^^ >p.then(() => x, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1356,12 +1356,12 @@ const p70 = p.then(() => undefined, undefined); > : ^^^^^^^^^^^^ >p.then(() => undefined, undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1374,12 +1374,12 @@ const p71 = p.then(() => undefined, null); > : ^^^^^^^^^^^^ >p.then(() => undefined, null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1390,12 +1390,12 @@ const p72 = p.then(() => undefined, () => 1); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => 1) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1410,12 +1410,12 @@ const p73 = p.then(() => undefined, () => x); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1429,12 +1429,12 @@ const p74 = p.then(() => undefined, () => undefined); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1449,12 +1449,12 @@ const p75 = p.then(() => undefined, () => null); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1467,12 +1467,12 @@ const p76 = p.then(() => undefined, () => {}); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => {}) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1485,12 +1485,12 @@ const p77 = p.then(() => undefined, () => {throw 1}); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => {throw 1}) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1505,12 +1505,12 @@ const p78 = p.then(() => undefined, () => Promise.resolve(1)); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1533,12 +1533,12 @@ const p79 = p.then(() => undefined, () => Promise.reject(1)); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1561,12 +1561,12 @@ const p80 = p.then(() => null, undefined); > : ^^^^^^^^^^^^ >p.then(() => null, undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >undefined : undefined @@ -1577,12 +1577,12 @@ const p81 = p.then(() => null, null); > : ^^^^^^^^^^^^ >p.then(() => null, null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ @@ -1591,12 +1591,12 @@ const p82 = p.then(() => null, () => 1); > : ^^^^^^^^^^^^ >p.then(() => null, () => 1) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => 1 : () => number @@ -1609,12 +1609,12 @@ const p83 = p.then(() => null, () => x); > : ^^^^^^^^^^^^ >p.then(() => null, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => x : () => any @@ -1626,12 +1626,12 @@ const p84 = p.then(() => null, () => undefined); > : ^^^^^^^^^^^^ >p.then(() => null, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => undefined : () => any @@ -1644,12 +1644,12 @@ const p85 = p.then(() => null, () => null); > : ^^^^^^^^^^^^ >p.then(() => null, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => null : () => any @@ -1660,12 +1660,12 @@ const p86 = p.then(() => null, () => {}); > : ^^^^^^^^^^^^ >p.then(() => null, () => {}) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => {} : () => void @@ -1676,12 +1676,12 @@ const p87 = p.then(() => null, () => {throw 1}); > : ^^^^^^^^^^^^ >p.then(() => null, () => {throw 1}) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => {throw 1} : () => never @@ -1694,12 +1694,12 @@ const p88 = p.then(() => null, () => Promise.resolve(1)); > : ^^^^^^^^^^^^ >p.then(() => null, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => Promise.resolve(1) : () => Promise @@ -1720,12 +1720,12 @@ const p89 = p.then(() => null, () => Promise.reject(1)); > : ^^^^^^^^^^^^ >p.then(() => null, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => any > : ^^^^^^^^^ >() => Promise.reject(1) : () => Promise @@ -1746,12 +1746,12 @@ const p90 = p.then(() => {}, undefined); > : ^^^^^^^^^^^^^ >p.then(() => {}, undefined) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >undefined : undefined @@ -1762,12 +1762,12 @@ const p91 = p.then(() => {}, null); > : ^^^^^^^^^^^^^ >p.then(() => {}, null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -1776,12 +1776,12 @@ const p92 = p.then(() => {}, () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => {}, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => 1 : () => number @@ -1794,12 +1794,12 @@ const p93 = p.then(() => {}, () => x); > : ^^^^^^^^^^^^ >p.then(() => {}, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => x : () => any @@ -1811,12 +1811,12 @@ const p94 = p.then(() => {}, () => undefined); > : ^^^^^^^^^^^^ >p.then(() => {}, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => undefined : () => any @@ -1829,12 +1829,12 @@ const p95 = p.then(() => {}, () => null); > : ^^^^^^^^^^^^ >p.then(() => {}, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => null : () => any @@ -1845,12 +1845,12 @@ const p96 = p.then(() => {}, () => {}); > : ^^^^^^^^^^^^^ >p.then(() => {}, () => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => {} : () => void @@ -1861,12 +1861,12 @@ const p97 = p.then(() => {}, () => {throw 1}); > : ^^^^^^^^^^^^^ >p.then(() => {}, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => {throw 1} : () => never @@ -1879,12 +1879,12 @@ const p98 = p.then(() => {}, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => {}, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => Promise.resolve(1) : () => Promise @@ -1905,12 +1905,12 @@ const p99 = p.then(() => {}, () => Promise.reject(1)); > : ^^^^^^^^^^^^^ >p.then(() => {}, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => Promise.reject(1) : () => Promise @@ -1931,12 +1931,12 @@ const pa0 = p.then(() => {throw 1}, undefined); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, undefined) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -1949,12 +1949,12 @@ const pa1 = p.then(() => {throw 1}, null); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, null) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -1965,12 +1965,12 @@ const pa2 = p.then(() => {throw 1}, () => 1); > : ^^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => 1) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -1985,12 +1985,12 @@ const pa3 = p.then(() => {throw 1}, () => x); > : ^^^^^^^^^^^^ >p.then(() => {throw 1}, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2004,12 +2004,12 @@ const pa4 = p.then(() => {throw 1}, () => undefined); > : ^^^^^^^^^^^^ >p.then(() => {throw 1}, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2024,12 +2024,12 @@ const pa5 = p.then(() => {throw 1}, () => null); > : ^^^^^^^^^^^^ >p.then(() => {throw 1}, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2042,12 +2042,12 @@ const pa6 = p.then(() => {throw 1}, () => {}); > : ^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2060,12 +2060,12 @@ const pa7 = p.then(() => {throw 1}, () => {throw 1}); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2080,12 +2080,12 @@ const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2108,12 +2108,12 @@ const pa9 = p.then(() => {throw 1}, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2136,12 +2136,12 @@ const pb0 = p.then(() => Promise.resolve("1"), undefined); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), undefined) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2162,12 +2162,12 @@ const pb1 = p.then(() => Promise.resolve("1"), null); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), null) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2186,12 +2186,12 @@ const pb2 = p.then(() => Promise.resolve("1"), () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2214,12 +2214,12 @@ const pb3 = p.then(() => Promise.resolve("1"), () => x); > : ^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2241,12 +2241,12 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined); > : ^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2269,12 +2269,12 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null); > : ^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2295,12 +2295,12 @@ const pb6 = p.then(() => Promise.resolve("1"), () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2321,12 +2321,12 @@ const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1}); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2349,12 +2349,12 @@ const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2385,12 +2385,12 @@ const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2421,12 +2421,12 @@ const pc0 = p.then(() => Promise.reject("1"), undefined); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), undefined) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2447,12 +2447,12 @@ const pc1 = p.then(() => Promise.reject("1"), null); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), null) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2471,12 +2471,12 @@ const pc2 = p.then(() => Promise.reject("1"), () => 1); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => 1) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2499,12 +2499,12 @@ const pc3 = p.then(() => Promise.reject("1"), () => x); > : ^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2526,12 +2526,12 @@ const pc4 = p.then(() => Promise.reject("1"), () => undefined); > : ^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2554,12 +2554,12 @@ const pc5 = p.then(() => Promise.reject("1"), () => null); > : ^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2580,12 +2580,12 @@ const pc6 = p.then(() => Promise.reject("1"), () => {}); > : ^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2606,12 +2606,12 @@ const pc7 = p.then(() => Promise.reject("1"), () => {throw 1}); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2634,12 +2634,12 @@ const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2670,12 +2670,12 @@ const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1)); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: (value: boolean) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: boolean) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise diff --git a/tests/baselines/reference/promiseTypeStrictNull.types b/tests/baselines/reference/promiseTypeStrictNull.types index afa722e1f9c37..7ff8d96c59faa 100644 --- a/tests/baselines/reference/promiseTypeStrictNull.types +++ b/tests/baselines/reference/promiseTypeStrictNull.types @@ -252,36 +252,36 @@ const p00 = p.catch(); > : ^^^^^^^^^^^^^^^^ >p.catch() : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const p01 = p.then(); >p01 : Promise > : ^^^^^^^^^^^^^^^^ >p.then() : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const p10 = p.catch(undefined); >p10 : Promise > : ^^^^^^^^^^^^^^^^ >p.catch(undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -290,24 +290,24 @@ const p11 = p.catch(null); > : ^^^^^^^^^^^^^^^^ >p.catch(null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const p12 = p.catch(() => 1); >p12 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => 1 : () => number > : ^^^^^^^^^^^^ >1 : 1 @@ -318,12 +318,12 @@ const p13 = p.catch(() => x); > : ^^^^^^^^^^^^ >p.catch(() => x) : Promise > : ^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -333,12 +333,12 @@ const p14 = p.catch(() => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -349,12 +349,12 @@ const p15 = p.catch(() => null); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ @@ -363,12 +363,12 @@ const p16 = p.catch(() => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -377,12 +377,12 @@ const p17 = p.catch(() => {throw 1}); > : ^^^^^^^^^^^^^^^^ >p.catch(() => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -393,12 +393,12 @@ const p18 = p.catch(() => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^ >p.catch(() => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject(1) : Promise @@ -417,12 +417,12 @@ const p19 = p.catch(() => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.catch(() => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->catch : (deferred onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>catch : (onrejected?: ((reason: any) => TResult | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve(1) : Promise @@ -441,12 +441,12 @@ const p20 = p.then(undefined); > : ^^^^^^^^^^^^^^^^ >p.then(undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -455,24 +455,24 @@ const p21 = p.then(null); > : ^^^^^^^^^^^^^^^^ >p.then(null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const p22 = p.then(() => 1); >p22 : Promise > : ^^^^^^^^^^^^^^^ >p.then(() => 1) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => 1 : () => number > : ^^^^^^^^^^^^ >1 : 1 @@ -483,12 +483,12 @@ const p23 = p.then(() => x); > : ^^^^^^^^^^^^ >p.then(() => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -498,12 +498,12 @@ const p24 = p.then(() => undefined); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -514,12 +514,12 @@ const p25 = p.then(() => null); > : ^^^^^^^^^^^^^ >p.then(() => null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ @@ -528,12 +528,12 @@ const p26 = p.then(() => {}); > : ^^^^^^^^^^^^^ >p.then(() => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -542,12 +542,12 @@ const p27 = p.then(() => {throw 1}); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -558,12 +558,12 @@ const p28 = p.then(() => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve(1) : Promise @@ -582,12 +582,12 @@ const p29 = p.then(() => Promise.reject(1)); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject(1) : Promise @@ -606,12 +606,12 @@ const p30 = p.then(undefined, undefined); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >undefined : undefined @@ -622,12 +622,12 @@ const p31 = p.then(undefined, null); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -636,12 +636,12 @@ const p32 = p.then(undefined, () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => 1 : () => number @@ -654,12 +654,12 @@ const p33 = p.then(undefined, () => x); > : ^^^^^^^^^^^^ >p.then(undefined, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => x : () => any @@ -671,12 +671,12 @@ const p34 = p.then(undefined, () => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => undefined : () => undefined @@ -689,12 +689,12 @@ const p35 = p.then(undefined, () => null); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => null : () => null @@ -705,12 +705,12 @@ const p36 = p.then(undefined, () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => {} : () => void @@ -721,12 +721,12 @@ const p37 = p.then(undefined, () => {throw 1}); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => {throw 1} : () => never @@ -739,12 +739,12 @@ const p38 = p.then(undefined, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(undefined, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => Promise.resolve(1) : () => Promise @@ -765,12 +765,12 @@ const p39 = p.then(undefined, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^ >p.then(undefined, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ >() => Promise.reject(1) : () => Promise @@ -791,12 +791,12 @@ const p40 = p.then(null, undefined); > : ^^^^^^^^^^^^^^^^ >p.then(null, undefined) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >undefined : undefined > : ^^^^^^^^^ @@ -805,24 +805,24 @@ const p41 = p.then(null, null); > : ^^^^^^^^^^^^^^^^ >p.then(null, null) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const p42 = p.then(null, () => 1); >p42 : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => 1 : () => number > : ^^^^^^^^^^^^ >1 : 1 @@ -833,12 +833,12 @@ const p43 = p.then(null, () => x); > : ^^^^^^^^^^^^ >p.then(null, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -848,12 +848,12 @@ const p44 = p.then(null, () => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -864,12 +864,12 @@ const p45 = p.then(null, () => null); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ @@ -878,12 +878,12 @@ const p46 = p.then(null, () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -892,12 +892,12 @@ const p47 = p.then(null, () => {throw 1}); > : ^^^^^^^^^^^^^^^^ >p.then(null, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -908,12 +908,12 @@ const p48 = p.then(null, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(null, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve(1) : Promise @@ -932,12 +932,12 @@ const p49 = p.then(null, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^ >p.then(null, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject(1) : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject(1) : Promise @@ -956,12 +956,12 @@ const p50 = p.then(() => "1", undefined); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", undefined) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -974,12 +974,12 @@ const p51 = p.then(() => "1", null); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", null) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -990,12 +990,12 @@ const p52 = p.then(() => "1", () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1010,12 +1010,12 @@ const p53 = p.then(() => "1", () => x); > : ^^^^^^^^^^^^ >p.then(() => "1", () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1029,12 +1029,12 @@ const p54 = p.then(() => "1", () => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1049,12 +1049,12 @@ const p55 = p.then(() => "1", () => null); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1067,12 +1067,12 @@ const p56 = p.then(() => "1", () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1085,12 +1085,12 @@ const p57 = p.then(() => "1", () => {throw 1}); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1105,12 +1105,12 @@ const p58 = p.then(() => "1", () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => "1", () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1133,12 +1133,12 @@ const p59 = p.then(() => "1", () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => "1", () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => "1" : () => string > : ^^^^^^^^^^^^ >"1" : "1" @@ -1161,12 +1161,12 @@ const p60 = p.then(() => x, undefined); > : ^^^^^^^^^^^^ >p.then(() => x, undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1178,12 +1178,12 @@ const p61 = p.then(() => x, null); > : ^^^^^^^^^^^^ >p.then(() => x, null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1193,12 +1193,12 @@ const p62 = p.then(() => x, () => 1); > : ^^^^^^^^^^^^ >p.then(() => x, () => 1) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1212,12 +1212,12 @@ const p63 = p.then(() => x, () => x); > : ^^^^^^^^^^^^ >p.then(() => x, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1230,12 +1230,12 @@ const p64 = p.then(() => x, () => undefined); > : ^^^^^^^^^^^^ >p.then(() => x, () => undefined) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1249,12 +1249,12 @@ const p65 = p.then(() => x, () => null); > : ^^^^^^^^^^^^ >p.then(() => x, () => null) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1266,12 +1266,12 @@ const p66 = p.then(() => x, () => {}); > : ^^^^^^^^^^^^ >p.then(() => x, () => {}) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1283,12 +1283,12 @@ const p67 = p.then(() => x, () => {throw 1}); > : ^^^^^^^^^^^^ >p.then(() => x, () => {throw 1}) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1302,12 +1302,12 @@ const p68 = p.then(() => x, () => Promise.resolve(1)); > : ^^^^^^^^^^^^ >p.then(() => x, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1329,12 +1329,12 @@ const p69 = p.then(() => x, () => Promise.reject(1)); > : ^^^^^^^^^^^^ >p.then(() => x, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => x : () => any > : ^^^^^^^^^ >x : any @@ -1356,12 +1356,12 @@ const p70 = p.then(() => undefined, undefined); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, undefined) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1374,12 +1374,12 @@ const p71 = p.then(() => undefined, null); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, null) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1390,12 +1390,12 @@ const p72 = p.then(() => undefined, () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1410,12 +1410,12 @@ const p73 = p.then(() => undefined, () => x); > : ^^^^^^^^^^^^ >p.then(() => undefined, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1429,12 +1429,12 @@ const p74 = p.then(() => undefined, () => undefined); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1449,12 +1449,12 @@ const p75 = p.then(() => undefined, () => null); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1467,12 +1467,12 @@ const p76 = p.then(() => undefined, () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1485,12 +1485,12 @@ const p77 = p.then(() => undefined, () => {throw 1}); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1505,12 +1505,12 @@ const p78 = p.then(() => undefined, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1533,12 +1533,12 @@ const p79 = p.then(() => undefined, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => undefined, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => undefined : () => undefined > : ^^^^^^^^^^^^^^^ >undefined : undefined @@ -1561,12 +1561,12 @@ const p80 = p.then(() => null, undefined); > : ^^^^^^^^^^^^^ >p.then(() => null, undefined) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >undefined : undefined @@ -1577,12 +1577,12 @@ const p81 = p.then(() => null, null); > : ^^^^^^^^^^^^^ >p.then(() => null, null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ @@ -1591,12 +1591,12 @@ const p82 = p.then(() => null, () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => null, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => 1 : () => number @@ -1609,12 +1609,12 @@ const p83 = p.then(() => null, () => x); > : ^^^^^^^^^^^^ >p.then(() => null, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => x : () => any @@ -1626,12 +1626,12 @@ const p84 = p.then(() => null, () => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => null, () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => undefined : () => undefined @@ -1644,12 +1644,12 @@ const p85 = p.then(() => null, () => null); > : ^^^^^^^^^^^^^ >p.then(() => null, () => null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => null : () => null @@ -1660,12 +1660,12 @@ const p86 = p.then(() => null, () => {}); > : ^^^^^^^^^^^^^^^^^^^^ >p.then(() => null, () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => {} : () => void @@ -1676,12 +1676,12 @@ const p87 = p.then(() => null, () => {throw 1}); > : ^^^^^^^^^^^^^ >p.then(() => null, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => {throw 1} : () => never @@ -1694,12 +1694,12 @@ const p88 = p.then(() => null, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => null, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => Promise.resolve(1) : () => Promise @@ -1720,12 +1720,12 @@ const p89 = p.then(() => null, () => Promise.reject(1)); > : ^^^^^^^^^^^^^ >p.then(() => null, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => null : () => null > : ^^^^^^^^^^ >() => Promise.reject(1) : () => Promise @@ -1746,12 +1746,12 @@ const p90 = p.then(() => {}, undefined); > : ^^^^^^^^^^^^^ >p.then(() => {}, undefined) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >undefined : undefined @@ -1762,12 +1762,12 @@ const p91 = p.then(() => {}, null); > : ^^^^^^^^^^^^^ >p.then(() => {}, null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ @@ -1776,12 +1776,12 @@ const p92 = p.then(() => {}, () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => {}, () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => 1 : () => number @@ -1794,12 +1794,12 @@ const p93 = p.then(() => {}, () => x); > : ^^^^^^^^^^^^ >p.then(() => {}, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => x : () => any @@ -1811,12 +1811,12 @@ const p94 = p.then(() => {}, () => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => {}, () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => undefined : () => undefined @@ -1829,12 +1829,12 @@ const p95 = p.then(() => {}, () => null); > : ^^^^^^^^^^^^^^^^^^^^ >p.then(() => {}, () => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => null : () => null @@ -1845,12 +1845,12 @@ const p96 = p.then(() => {}, () => {}); > : ^^^^^^^^^^^^^ >p.then(() => {}, () => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => {} : () => void @@ -1861,12 +1861,12 @@ const p97 = p.then(() => {}, () => {throw 1}); > : ^^^^^^^^^^^^^ >p.then(() => {}, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => {throw 1} : () => never @@ -1879,12 +1879,12 @@ const p98 = p.then(() => {}, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => {}, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => Promise.resolve(1) : () => Promise @@ -1905,12 +1905,12 @@ const p99 = p.then(() => {}, () => Promise.reject(1)); > : ^^^^^^^^^^^^^ >p.then(() => {}, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {} : () => void > : ^^^^^^^^^^ >() => Promise.reject(1) : () => Promise @@ -1931,12 +1931,12 @@ const pa0 = p.then(() => {throw 1}, undefined); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, undefined) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -1949,12 +1949,12 @@ const pa1 = p.then(() => {throw 1}, null); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, null) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -1965,12 +1965,12 @@ const pa2 = p.then(() => {throw 1}, () => 1); > : ^^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => 1) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -1985,12 +1985,12 @@ const pa3 = p.then(() => {throw 1}, () => x); > : ^^^^^^^^^^^^ >p.then(() => {throw 1}, () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2004,12 +2004,12 @@ const pa4 = p.then(() => {throw 1}, () => undefined); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2024,12 +2024,12 @@ const pa5 = p.then(() => {throw 1}, () => null); > : ^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2042,12 +2042,12 @@ const pa6 = p.then(() => {throw 1}, () => {}); > : ^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2060,12 +2060,12 @@ const pa7 = p.then(() => {throw 1}, () => {throw 1}); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2080,12 +2080,12 @@ const pa8 = p.then(() => {throw 1}, () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2108,12 +2108,12 @@ const pa9 = p.then(() => {throw 1}, () => Promise.reject(1)); > : ^^^^^^^^^^^^^^ >p.then(() => {throw 1}, () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => {throw 1} : () => never > : ^^^^^^^^^^^ >1 : 1 @@ -2136,12 +2136,12 @@ const pb0 = p.then(() => Promise.resolve("1"), undefined); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), undefined) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2162,12 +2162,12 @@ const pb1 = p.then(() => Promise.resolve("1"), null); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), null) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2186,12 +2186,12 @@ const pb2 = p.then(() => Promise.resolve("1"), () => 1); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => 1) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2214,12 +2214,12 @@ const pb3 = p.then(() => Promise.resolve("1"), () => x); > : ^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2241,12 +2241,12 @@ const pb4 = p.then(() => Promise.resolve("1"), () => undefined); > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2269,12 +2269,12 @@ const pb5 = p.then(() => Promise.resolve("1"), () => null); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => null) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2295,12 +2295,12 @@ const pb6 = p.then(() => Promise.resolve("1"), () => {}); > : ^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => {}) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2321,12 +2321,12 @@ const pb7 = p.then(() => Promise.resolve("1"), () => {throw 1}); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2349,12 +2349,12 @@ const pb8 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2385,12 +2385,12 @@ const pb9 = p.then(() => Promise.resolve("1"), () => Promise.reject(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.resolve("1"), () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.resolve("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve("1") : Promise @@ -2421,12 +2421,12 @@ const pc0 = p.then(() => Promise.reject("1"), undefined); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), undefined) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2447,12 +2447,12 @@ const pc1 = p.then(() => Promise.reject("1"), null); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), null) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2471,12 +2471,12 @@ const pc2 = p.then(() => Promise.reject("1"), () => 1); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => 1) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2499,12 +2499,12 @@ const pc3 = p.then(() => Promise.reject("1"), () => x); > : ^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => x) : Promise > : ^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2526,12 +2526,12 @@ const pc4 = p.then(() => Promise.reject("1"), () => undefined); > : ^^^^^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => undefined) : Promise > : ^^^^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2554,12 +2554,12 @@ const pc5 = p.then(() => Promise.reject("1"), () => null); > : ^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => null) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2580,12 +2580,12 @@ const pc6 = p.then(() => Promise.reject("1"), () => {}); > : ^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => {}) : Promise > : ^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2606,12 +2606,12 @@ const pc7 = p.then(() => Promise.reject("1"), () => {throw 1}); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => {throw 1}) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2634,12 +2634,12 @@ const pc8 = p.then(() => Promise.reject("1"), () => Promise.resolve(1)); > : ^^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => Promise.resolve(1)) : Promise > : ^^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise @@ -2670,12 +2670,12 @@ const pc9 = p.then(() => Promise.reject("1"), () => Promise.reject(1)); > : ^^^^^^^^^^^^^^ >p.then(() => Promise.reject("1"), () => Promise.reject(1)) : Promise > : ^^^^^^^^^^^^^^ ->p.then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => Promise.reject("1") : () => Promise > : ^^^^^^^^^^^^^^^^^^^^ >Promise.reject("1") : Promise diff --git a/tests/baselines/reference/promiseVoidErrorCallback.types b/tests/baselines/reference/promiseVoidErrorCallback.types index 0af519dfa2a2f..1ab8bcbae7475 100644 --- a/tests/baselines/reference/promiseVoidErrorCallback.types +++ b/tests/baselines/reference/promiseVoidErrorCallback.types @@ -68,20 +68,20 @@ var x3 = f1() > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ >f1() .then(f2, (e: Error) => { throw e;}) .then((x: T2) => { return { __t3: x.__t2 + "bar" };}) : Promise<{ __t3: string; }> > : ^^^^^^^^^^^^^^^^^^^^^^^^^^ ->f1() .then(f2, (e: Error) => { throw e;}) .then : (deferred onfulfilled?: (value: T2) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f1() .then(f2, (e: Error) => { throw e;}) .then : (onfulfilled?: (value: T2) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >f1() .then(f2, (e: Error) => { throw e;}) : Promise > : ^^^^^^^^^^^ ->f1() .then : (deferred onfulfilled?: (value: T1) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>f1() .then : (onfulfilled?: (value: T1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >f1() : Promise > : ^^^^^^^^^^^ >f1 : () => Promise > : ^^^^^^ .then(f2, (e: Error) => { ->then : (deferred onfulfilled?: (value: T1) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: T1) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >f2 : (x: T1) => T2 > : ^ ^^ ^^^^^ >(e: Error) => { throw e;} : (e: Error) => never @@ -95,8 +95,8 @@ var x3 = f1() }) .then((x: T2) => { ->then : (deferred onfulfilled?: (value: T2) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: T2) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(x: T2) => { return { __t3: x.__t2 + "bar" };} : (x: T2) => { __t3: string; } > : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ >x : T2 diff --git a/tests/baselines/reference/promises.types b/tests/baselines/reference/promises.types index 301487e8f2993..0618d6e26e634 100644 --- a/tests/baselines/reference/promises.types +++ b/tests/baselines/reference/promises.types @@ -3,16 +3,16 @@ === promises.ts === interface Promise { then(success?: (value: T) => U): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => U): Promise; (success?: (value: T) => Promise): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => U): Promise; (success?: (value: T) => Promise): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^^ ^^^ >success : (value: T) => U > : ^ ^^ ^^^^^ >value : T > : ^ then(success?: (value: T) => Promise): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => U_1): Promise; (success?: (value: T) => Promise): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (success?: (value: T) => U_1): Promise; (success?: (value: T) => Promise): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^^^^^^ ^^^ ^^^ ^^^ ^^ ^^^ ^^^ ^^^ >success : (value: T) => Promise > : ^ ^^ ^^^^^ >value : T diff --git a/tests/baselines/reference/promisesWithConstraints.types b/tests/baselines/reference/promisesWithConstraints.types index aa219e8ddc799..2ea111f3c24e2 100644 --- a/tests/baselines/reference/promisesWithConstraints.types +++ b/tests/baselines/reference/promisesWithConstraints.types @@ -3,8 +3,8 @@ === promisesWithConstraints.ts === interface Promise { then(cb: (x: T) => Promise): Promise; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (cb: (x: T) => Promise): Promise; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (cb: (x: T) => Promise): Promise; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ >cb : (x: T) => Promise > : ^ ^^ ^^^^^ >x : T diff --git a/tests/baselines/reference/specializationError.types b/tests/baselines/reference/specializationError.types index 1cc1af596b436..76d92b4d4b8a4 100644 --- a/tests/baselines/reference/specializationError.types +++ b/tests/baselines/reference/specializationError.types @@ -3,8 +3,8 @@ === specializationError.ts === interface Promise { then(value: T): void; ->then : { (deferred onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (value: T): void; } -> : ^^^ ^^^^^^ ^^^^^^^^^^ ^ ^^^ ^^ ^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ +>then : { (onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; (value: T): void; } +> : ^^^ ^^^^^^ ^^^^^^^^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ >value : T > : ^ } diff --git a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types index 20c31c2018dc8..e56f972e46f73 100644 --- a/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types +++ b/tests/baselines/reference/syntheticDefaultExportsWithDynamicImports.types @@ -15,14 +15,14 @@ export = packageExport; import("package").then(({default: foo}) => foo(42)); >import("package").then(({default: foo}) => foo(42)) : Promise > : ^^^^^^^^^^^^^^^ ->import("package").then : string; }, TResult2 = never>(deferred onfulfilled?: (value: { default: (x: number) => string; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>import("package").then : string; }, TResult2 = never>(onfulfilled?: (value: { default: (x: number) => string; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >import("package") : Promise<{ default: (x: number) => string; }> > : ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^ >"package" : "package" > : ^^^^^^^^^ ->then : string; }, TResult2 = never>(deferred onfulfilled?: (value: { default: (x: number) => string; }) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : string; }, TResult2 = never>(onfulfilled?: (value: { default: (x: number) => string; }) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >({default: foo}) => foo(42) : ({ default: foo }: { default: (x: number) => string; }) => string > : ^ ^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^^^^ >default : any diff --git a/tests/baselines/reference/truthinessPromiseCoercion.types b/tests/baselines/reference/truthinessPromiseCoercion.types index ed5ee26a59cb8..595d1b72af1a1 100644 --- a/tests/baselines/reference/truthinessPromiseCoercion.types +++ b/tests/baselines/reference/truthinessPromiseCoercion.types @@ -118,12 +118,12 @@ async function g() { > : ^^^^^^^^^^^^^^^ >p.then.length : number > : ^^^^^^ ->p.then : (deferred onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p.then : (onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >p : Promise > : ^^^^^^^^^^^^^^^ ->then : (deferred onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: number) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >length : number > : ^^^^^^ @@ -239,14 +239,14 @@ async function i(): Promise { pf().then(); >pf().then() : Promise > : ^^^^^^^^^^^^^^^^ ->pf().then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>pf().then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >pf() : Promise > : ^^^^^^^^^^^^^^^^ >pf : () => Promise > : ^^^^^^ ->then : (deferred onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise -> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: ((value: boolean) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +> : ^ ^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ } return "false"; >"false" : "false" diff --git a/tests/baselines/reference/unionAndIntersectionInference1.types b/tests/baselines/reference/unionAndIntersectionInference1.types index af71a6bdb5746..1c0e04a88fb97 100644 --- a/tests/baselines/reference/unionAndIntersectionInference1.types +++ b/tests/baselines/reference/unionAndIntersectionInference1.types @@ -283,8 +283,8 @@ const createTestAsync = (): Promise => Promise.resolve().then(() => ({ na > : ^^^^^^ >Promise.resolve().then(() => ({ name: 'test' })) : Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->Promise.resolve().then : (deferred onfulfilled?: (value: void) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>Promise.resolve().then : (onfulfilled?: (value: void) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >Promise.resolve() : Promise > : ^^^^^^^^^^^^^ >Promise.resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } @@ -293,8 +293,8 @@ const createTestAsync = (): Promise => Promise.resolve().then(() => ({ na > : ^^^^^^^^^^^^^^^^^^ >resolve : { (): Promise; (value: T): Promise>; (value: T | PromiseLike): Promise>; } > : ^^^^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ->then : (deferred onfulfilled?: (value: void) => TResult1 | PromiseLike, deferred onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise -> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : (onfulfilled?: (value: void) => TResult1 | PromiseLike, onrejected?: (reason: any) => TResult2 | PromiseLike) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >() => ({ name: 'test' }) : () => { name: "test"; } > : ^^^^^^^^^^^^^^^^^^^^^^^ >({ name: 'test' }) : { name: "test"; } diff --git a/tests/baselines/reference/unionOfClassCalls.types b/tests/baselines/reference/unionOfClassCalls.types index 6921455ef0d07..92889ae878fbb 100644 --- a/tests/baselines/reference/unionOfClassCalls.types +++ b/tests/baselines/reference/unionOfClassCalls.types @@ -322,8 +322,8 @@ declare var a: Bar | Baz; a.doThing().then((result: Bar | Baz) => { >a.doThing().then((result: Bar | Baz) => { // whatever}) : Promise > : ^^^^^^^^^^^^^ ->a.doThing().then : ((deferred onfulfilled?: ((value: Baz) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) | ((deferred onfulfilled?: ((value: Bar) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) -> : ^^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>a.doThing().then : ((onfulfilled?: ((value: Baz) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) | ((onfulfilled?: ((value: Bar) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) +> : ^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >a.doThing() : Promise | Promise > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ >a.doThing : (() => Promise) | (() => Promise) @@ -332,8 +332,8 @@ a.doThing().then((result: Bar | Baz) => { > : ^^^^^^^^^ >doThing : (() => Promise) | (() => Promise) > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->then : ((deferred onfulfilled?: ((value: Baz) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) | ((deferred onfulfilled?: ((value: Bar) => TResult1 | PromiseLike) | null | undefined, deferred onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) -> : ^^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^ ^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>then : ((onfulfilled?: ((value: Baz) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) | ((onfulfilled?: ((value: Bar) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise) +> : ^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >(result: Bar | Baz) => { // whatever} : (result: Bar | Baz) => void > : ^ ^^ ^^^^^^^^^ >result : Bar | Baz diff --git a/tests/baselines/reference/usePromiseFinally.types b/tests/baselines/reference/usePromiseFinally.types index 5ce6c22b50603..44b9fcaaf2eaf 100644 --- a/tests/baselines/reference/usePromiseFinally.types +++ b/tests/baselines/reference/usePromiseFinally.types @@ -6,8 +6,8 @@ let promise1 = new Promise(function(resolve, reject) {}) > : ^^^^^^^^^^^^^^^^ >new Promise(function(resolve, reject) {}) .finally(function() {}) : Promise > : ^^^^^^^^^^^^^^^^ ->new Promise(function(resolve, reject) {}) .finally : (deferred onfinally?: () => void) => Promise -> : ^ ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ +>new Promise(function(resolve, reject) {}) .finally : (onfinally?: () => void) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ >new Promise(function(resolve, reject) {}) : Promise > : ^^^^^^^^^^^^^^^^ >Promise : PromiseConstructor @@ -20,8 +20,8 @@ let promise1 = new Promise(function(resolve, reject) {}) > : ^ ^^^ ^^^^^ .finally(function() {}); ->finally : (deferred onfinally?: () => void) => Promise -> : ^ ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ +>finally : (onfinally?: () => void) => Promise +> : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ >function() {} : () => void > : ^^^^^^^^^^ From 3508e0ee86e8ee905e1126a3147345863fad5339 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 11 Jul 2024 15:55:41 -0700 Subject: [PATCH 22/30] Fix formatting --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index a76eda019f6dd..f08cfc487a324 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -40888,7 +40888,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (node.dotDotDotToken && !isBindingPattern(node.name) && !isTypeAssignableTo(getReducedType(getTypeOfSymbol(node.symbol)), anyReadonlyArrayType)) { error(node, Diagnostics.A_rest_parameter_must_be_of_an_array_type); } - if (hasEffectiveModifier(node, (ModifierFlags.Deferred | ModifierFlags.JSDocDeferred))) { + if (hasEffectiveModifier(node, ModifierFlags.Deferred | ModifierFlags.JSDocDeferred)) { const funcType = node.dotDotDotToken ? createArrayType(globalFunctionType, /*readonly*/ true) : globalFunctionType; if (!areTypesComparable(getTypeOfSymbol(node.symbol), funcType)) { error(node, Diagnostics.A_deferred_parameter_must_have_a_type_that_permits_functions); From 01670b06a5286fdc5aff16c02b8d776de8fb7261 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Fri, 12 Jul 2024 07:54:18 -0700 Subject: [PATCH 23/30] Add tests --- .../reference/deferredCallbacks.errors.txt | 259 +++++ .../baselines/reference/deferredCallbacks.js | 464 ++++++++ .../reference/deferredCallbacks.symbols | 627 ++++++++++ .../reference/deferredCallbacks.types | 1035 +++++++++++++++++ tests/cases/compiler/deferredCallbacks.ts | 238 ++++ 5 files changed, 2623 insertions(+) create mode 100644 tests/baselines/reference/deferredCallbacks.errors.txt create mode 100644 tests/baselines/reference/deferredCallbacks.js create mode 100644 tests/baselines/reference/deferredCallbacks.symbols create mode 100644 tests/baselines/reference/deferredCallbacks.types create mode 100644 tests/cases/compiler/deferredCallbacks.ts diff --git a/tests/baselines/reference/deferredCallbacks.errors.txt b/tests/baselines/reference/deferredCallbacks.errors.txt new file mode 100644 index 0000000000000..c3427c4702b3c --- /dev/null +++ b/tests/baselines/reference/deferredCallbacks.errors.txt @@ -0,0 +1,259 @@ +deferredCallbacks.ts(119,22): error TS2869: A 'deferred' parameter must have a type that permits functions. +deferredCallbacks.ts(120,22): error TS2869: A 'deferred' parameter must have a type that permits functions. +deferredCallbacks.ts(121,22): error TS2869: A 'deferred' parameter must have a type that permits functions. +deferredCallbacks.ts(128,13): error TS2869: A 'deferred' parameter must have a type that permits functions. +deferredCallbacks.ts(129,13): error TS2869: A 'deferred' parameter must have a type that permits functions. +deferredCallbacks.ts(130,13): error TS2869: A 'deferred' parameter must have a type that permits functions. +deferredCallbacks.ts(131,14): error TS1070: 'deferred' modifier cannot appear on a type member. + + +==== deferredCallbacks.ts (7 errors) ==== + declare function immediate(cb: () => void): void; + declare function deferred1(deferred cb: () => void): void; + declare function deferred2(/** @deferred */ cb: () => void): void; + declare function deferred3(/** @deferred */ deferred cb: () => void): void; + + function f01() { + let x: string | number = "OK"; + immediate(() => { + x = 42; + }); + x; // string | number + } + + function f02() { + let x: string | number = "OK"; + deferred1(() => { + x = 42; + }); + x; // string + } + + function f03() { + let x: string | number = "OK"; + deferred2(() => { + x = 42; + }); + x; // string + } + + function f04() { + let x: string | number = "OK"; + deferred3(() => { + x = 42; + }); + x; // string + } + + // Parameter is considered deferred if one or more overloads defer that parameter + + declare function overloaded(cb: (x: T) => T): void; + declare function overloaded(cb: (x: T, y: T) => T): void; + declare function overloaded(deferred cb: (...args: any) => any): void; + + function f05() { + let x: string | number = "OK"; + overloaded(() => { + x = 42; + }); + x.length; + } + + // deferred is permitted on a rest parameter + + declare function invokeImmediate(...args: ((...args: any) => any)[]): void; + declare function invokeDeferred(deferred ...args: ((...args: any) => any)[]): void; + + function f06() { + let a = []; + a.push("abc"); + a; // string[] + invokeImmediate( + () => { + a; // string[] + a.push(42); + a; // (string | number)[] + }, + () => { + a; // string[] + a.push(true); + a; // (string | boolean)[] + } + ); + a; // (string | number | boolean)[] + } + + function f07() { + let a = []; + a.push("abc"); + a; // string[] + invokeDeferred( + () => { + a; // string[] + a.push(42); + a; // (string | number)[] + }, + () => { + a; // string[] + a.push(true); + a; // (string | boolean)[] + } + ); + a; // string[] + } + + // deferred modifier must precede public/private/protected/readonly + + class CC { + constructor(deferred public readonly x: () => void) {} + } + + // deferred requires parameter to have type that permits functions + + declare function f10(deferred f: () => void): void; + declare function f11(deferred f: Function): void; + declare function f12(deferred f: any): void; + declare function f13(deferred f: object): void; + declare function f14(deferred f: {}): void; + declare function f15(deferred f: unknown): void; + declare function f16(deferred f: T): void; + declare function f17 any>(deferred f: T): void; + declare function f18 void)>(deferred f: T): void; + + declare function f20(deferred ...funcs: Function[]): void; + declare function f21 any)[]>(deferred ...funcs: T): void; + declare function f22 void))[]>(deferred ...funcs: T): void; + declare function f23 void)[]>(deferred ...funcs: T): void; + declare function f24 void)[]>(deferred ...funcs: T | string[]): void; + + declare function f30(deferred f: { foo(): void }): void; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2869: A 'deferred' parameter must have a type that permits functions. + declare function f31(deferred f: number): void; + ~~~~~~~~~~~~~~~~~~ +!!! error TS2869: A 'deferred' parameter must have a type that permits functions. + declare function f32(deferred ...funcs: number[]): void; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2869: A 'deferred' parameter must have a type that permits functions. + + type T10 = (deferred f: () => void) => void; + type T11 = (deferred f: { (): void }) => void; + type T12 = (deferred f: Function) => void; + type T13 = (deferred f: any) => void; + + type T20 = (deferred f: { foo(): void }) => void; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2869: A 'deferred' parameter must have a type that permits functions. + type T21 = (deferred f: number) => void; + ~~~~~~~~~~~~~~~~~~ +!!! error TS2869: A 'deferred' parameter must have a type that permits functions. + type T22 = (deferred ...funcs: number[]) => void; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2869: A 'deferred' parameter must have a type that permits functions. + type T23 = { deferred x: () => void }; + ~~~~~~~~ +!!! error TS1070: 'deferred' modifier cannot appear on a type member. + + // deferred modifier is not captured in argument list tuples + + declare function doStuff(deferred f: () => void): void; + + declare function recreate(f: (...args: A) => R): (...args: A) => R; + declare function recreateDeferred1(f: (deferred ...args: A) => R): (...args: A) => R; + declare function recreateDeferred2(f: (...args: A) => R): (deferred ...args: A) => R; + + function ff1() { + let x: string | number; + x = 123; + doStuff(() => { + x = "hi"; + }); + x; // number + } + + function ff2() { + let y: string | number; + y = 123; + recreate(doStuff)(() => { + y = "hi"; + }); + y; // string | number + } + + function ff3() { + let z: string | number; + z = 123; + recreateDeferred1(doStuff)(() => { + z = "hi"; + }); + z; // string | number + } + + function ff4() { + let z: string | number; + z = 123; + recreateDeferred2(doStuff)(() => { + z = "hi"; + }); + z; // number + } + + // https://github.com/microsoft/TypeScript/issues/11498 + + declare function mystery(cb: () => void): void; + + function fx1() { + let x: string | number = "OK"; + x; // string + mystery(() => { + x = 10; + }); + x; // string | number + if (x === 10) {} + } + + // https://github.com/microsoft/TypeScript/issues/15380 + + class Foo { + public bar: string = ""; + } + + function fx2() { + let foo: Foo | null = null; + [1].forEach((item) => { + foo = new Foo(); + }); + if (foo) { + foo.bar; + } + } + + // https://github.com/microsoft/TypeScript/issues/57880 + + const call = (f: () => void) => f(); + + const fx3 = () => { + let a: undefined | number = undefined; + call(() => { a = 1; }); + if (a !== undefined) { + a.toString(); + } + }; + + // https://github.com/microsoft/TypeScript/issues/58291 + + async function execute(onError: (_err: Error | undefined) => void) { + onError(new Error("a")); + } + + async function run() { + let result: boolean = true; + await execute(() => { + result = false; + }); + if (result === false) { + console.log("error"); + } + return result; + } + \ No newline at end of file diff --git a/tests/baselines/reference/deferredCallbacks.js b/tests/baselines/reference/deferredCallbacks.js new file mode 100644 index 0000000000000..da1accd10bbd5 --- /dev/null +++ b/tests/baselines/reference/deferredCallbacks.js @@ -0,0 +1,464 @@ +//// [tests/cases/compiler/deferredCallbacks.ts] //// + +//// [deferredCallbacks.ts] +declare function immediate(cb: () => void): void; +declare function deferred1(deferred cb: () => void): void; +declare function deferred2(/** @deferred */ cb: () => void): void; +declare function deferred3(/** @deferred */ deferred cb: () => void): void; + +function f01() { + let x: string | number = "OK"; + immediate(() => { + x = 42; + }); + x; // string | number +} + +function f02() { + let x: string | number = "OK"; + deferred1(() => { + x = 42; + }); + x; // string +} + +function f03() { + let x: string | number = "OK"; + deferred2(() => { + x = 42; + }); + x; // string +} + +function f04() { + let x: string | number = "OK"; + deferred3(() => { + x = 42; + }); + x; // string +} + +// Parameter is considered deferred if one or more overloads defer that parameter + +declare function overloaded(cb: (x: T) => T): void; +declare function overloaded(cb: (x: T, y: T) => T): void; +declare function overloaded(deferred cb: (...args: any) => any): void; + +function f05() { + let x: string | number = "OK"; + overloaded(() => { + x = 42; + }); + x.length; +} + +// deferred is permitted on a rest parameter + +declare function invokeImmediate(...args: ((...args: any) => any)[]): void; +declare function invokeDeferred(deferred ...args: ((...args: any) => any)[]): void; + +function f06() { + let a = []; + a.push("abc"); + a; // string[] + invokeImmediate( + () => { + a; // string[] + a.push(42); + a; // (string | number)[] + }, + () => { + a; // string[] + a.push(true); + a; // (string | boolean)[] + } + ); + a; // (string | number | boolean)[] +} + +function f07() { + let a = []; + a.push("abc"); + a; // string[] + invokeDeferred( + () => { + a; // string[] + a.push(42); + a; // (string | number)[] + }, + () => { + a; // string[] + a.push(true); + a; // (string | boolean)[] + } + ); + a; // string[] +} + +// deferred modifier must precede public/private/protected/readonly + +class CC { + constructor(deferred public readonly x: () => void) {} +} + +// deferred requires parameter to have type that permits functions + +declare function f10(deferred f: () => void): void; +declare function f11(deferred f: Function): void; +declare function f12(deferred f: any): void; +declare function f13(deferred f: object): void; +declare function f14(deferred f: {}): void; +declare function f15(deferred f: unknown): void; +declare function f16(deferred f: T): void; +declare function f17 any>(deferred f: T): void; +declare function f18 void)>(deferred f: T): void; + +declare function f20(deferred ...funcs: Function[]): void; +declare function f21 any)[]>(deferred ...funcs: T): void; +declare function f22 void))[]>(deferred ...funcs: T): void; +declare function f23 void)[]>(deferred ...funcs: T): void; +declare function f24 void)[]>(deferred ...funcs: T | string[]): void; + +declare function f30(deferred f: { foo(): void }): void; +declare function f31(deferred f: number): void; +declare function f32(deferred ...funcs: number[]): void; + +type T10 = (deferred f: () => void) => void; +type T11 = (deferred f: { (): void }) => void; +type T12 = (deferred f: Function) => void; +type T13 = (deferred f: any) => void; + +type T20 = (deferred f: { foo(): void }) => void; +type T21 = (deferred f: number) => void; +type T22 = (deferred ...funcs: number[]) => void; +type T23 = { deferred x: () => void }; + +// deferred modifier is not captured in argument list tuples + +declare function doStuff(deferred f: () => void): void; + +declare function recreate(f: (...args: A) => R): (...args: A) => R; +declare function recreateDeferred1(f: (deferred ...args: A) => R): (...args: A) => R; +declare function recreateDeferred2(f: (...args: A) => R): (deferred ...args: A) => R; + +function ff1() { + let x: string | number; + x = 123; + doStuff(() => { + x = "hi"; + }); + x; // number +} + +function ff2() { + let y: string | number; + y = 123; + recreate(doStuff)(() => { + y = "hi"; + }); + y; // string | number +} + +function ff3() { + let z: string | number; + z = 123; + recreateDeferred1(doStuff)(() => { + z = "hi"; + }); + z; // string | number +} + +function ff4() { + let z: string | number; + z = 123; + recreateDeferred2(doStuff)(() => { + z = "hi"; + }); + z; // number +} + +// https://github.com/microsoft/TypeScript/issues/11498 + +declare function mystery(cb: () => void): void; + +function fx1() { + let x: string | number = "OK"; + x; // string + mystery(() => { + x = 10; + }); + x; // string | number + if (x === 10) {} +} + +// https://github.com/microsoft/TypeScript/issues/15380 + +class Foo { + public bar: string = ""; +} + +function fx2() { + let foo: Foo | null = null; + [1].forEach((item) => { + foo = new Foo(); + }); + if (foo) { + foo.bar; + } +} + +// https://github.com/microsoft/TypeScript/issues/57880 + +const call = (f: () => void) => f(); + +const fx3 = () => { + let a: undefined | number = undefined; + call(() => { a = 1; }); + if (a !== undefined) { + a.toString(); + } +}; + +// https://github.com/microsoft/TypeScript/issues/58291 + +async function execute(onError: (_err: Error | undefined) => void) { + onError(new Error("a")); +} + +async function run() { + let result: boolean = true; + await execute(() => { + result = false; + }); + if (result === false) { + console.log("error"); + } + return result; +} + + +//// [deferredCallbacks.js] +"use strict"; +function f01() { + let x = "OK"; + immediate(() => { + x = 42; + }); + x; // string | number +} +function f02() { + let x = "OK"; + deferred1(() => { + x = 42; + }); + x; // string +} +function f03() { + let x = "OK"; + deferred2(() => { + x = 42; + }); + x; // string +} +function f04() { + let x = "OK"; + deferred3(() => { + x = 42; + }); + x; // string +} +function f05() { + let x = "OK"; + overloaded(() => { + x = 42; + }); + x.length; +} +function f06() { + let a = []; + a.push("abc"); + a; // string[] + invokeImmediate(() => { + a; // string[] + a.push(42); + a; // (string | number)[] + }, () => { + a; // string[] + a.push(true); + a; // (string | boolean)[] + }); + a; // (string | number | boolean)[] +} +function f07() { + let a = []; + a.push("abc"); + a; // string[] + invokeDeferred(() => { + a; // string[] + a.push(42); + a; // (string | number)[] + }, () => { + a; // string[] + a.push(true); + a; // (string | boolean)[] + }); + a; // string[] +} +// deferred modifier must precede public/private/protected/readonly +class CC { + x; + constructor(x) { + this.x = x; + } +} +function ff1() { + let x; + x = 123; + doStuff(() => { + x = "hi"; + }); + x; // number +} +function ff2() { + let y; + y = 123; + recreate(doStuff)(() => { + y = "hi"; + }); + y; // string | number +} +function ff3() { + let z; + z = 123; + recreateDeferred1(doStuff)(() => { + z = "hi"; + }); + z; // string | number +} +function ff4() { + let z; + z = 123; + recreateDeferred2(doStuff)(() => { + z = "hi"; + }); + z; // number +} +function fx1() { + let x = "OK"; + x; // string + mystery(() => { + x = 10; + }); + x; // string | number + if (x === 10) { } +} +// https://github.com/microsoft/TypeScript/issues/15380 +class Foo { + bar = ""; +} +function fx2() { + let foo = null; + [1].forEach((item) => { + foo = new Foo(); + }); + if (foo) { + foo.bar; + } +} +// https://github.com/microsoft/TypeScript/issues/57880 +const call = (f) => f(); +const fx3 = () => { + let a = undefined; + call(() => { a = 1; }); + if (a !== undefined) { + a.toString(); + } +}; +// https://github.com/microsoft/TypeScript/issues/58291 +async function execute(onError) { + onError(new Error("a")); +} +async function run() { + let result = true; + await execute(() => { + result = false; + }); + if (result === false) { + console.log("error"); + } + return result; +} + + +//// [deferredCallbacks.d.ts] +declare function immediate(cb: () => void): void; +declare function deferred1(deferred cb: () => void): void; +declare function deferred2(/** @deferred */ cb: () => void): void; +declare function deferred3(/** @deferred */ deferred cb: () => void): void; +declare function f01(): void; +declare function f02(): void; +declare function f03(): void; +declare function f04(): void; +declare function overloaded(cb: (x: T) => T): void; +declare function overloaded(cb: (x: T, y: T) => T): void; +declare function overloaded(deferred cb: (...args: any) => any): void; +declare function f05(): void; +declare function invokeImmediate(...args: ((...args: any) => any)[]): void; +declare function invokeDeferred(deferred ...args: ((...args: any) => any)[]): void; +declare function f06(): void; +declare function f07(): void; +declare class CC { + deferred readonly x: () => void; + constructor(x: () => void); +} +declare function f10(deferred f: () => void): void; +declare function f11(deferred f: Function): void; +declare function f12(deferred f: any): void; +declare function f13(deferred f: object): void; +declare function f14(deferred f: {}): void; +declare function f15(deferred f: unknown): void; +declare function f16(deferred f: T): void; +declare function f17 any>(deferred f: T): void; +declare function f18 void)>(deferred f: T): void; +declare function f20(deferred ...funcs: Function[]): void; +declare function f21 any)[]>(deferred ...funcs: T): void; +declare function f22 void))[]>(deferred ...funcs: T): void; +declare function f23 void)[]>(deferred ...funcs: T): void; +declare function f24 void)[]>(deferred ...funcs: T | string[]): void; +declare function f30(deferred f: { + foo(): void; +}): void; +declare function f31(deferred f: number): void; +declare function f32(deferred ...funcs: number[]): void; +type T10 = (deferred f: () => void) => void; +type T11 = (deferred f: { + (): void; +}) => void; +type T12 = (deferred f: Function) => void; +type T13 = (deferred f: any) => void; +type T20 = (deferred f: { + foo(): void; +}) => void; +type T21 = (deferred f: number) => void; +type T22 = (deferred ...funcs: number[]) => void; +type T23 = { + deferred x: () => void; +}; +declare function doStuff(deferred f: () => void): void; +declare function recreate(f: (...args: A) => R): (...args: A) => R; +declare function recreateDeferred1(f: (deferred ...args: A) => R): (...args: A) => R; +declare function recreateDeferred2(f: (...args: A) => R): (deferred ...args: A) => R; +declare function ff1(): void; +declare function ff2(): void; +declare function ff3(): void; +declare function ff4(): void; +declare function mystery(cb: () => void): void; +declare function fx1(): void; +declare class Foo { + bar: string; +} +declare function fx2(): void; +declare const call: (f: () => void) => void; +declare const fx3: () => void; +declare function execute(onError: (_err: Error | undefined) => void): Promise; +declare function run(): Promise; diff --git a/tests/baselines/reference/deferredCallbacks.symbols b/tests/baselines/reference/deferredCallbacks.symbols new file mode 100644 index 0000000000000..1d8162916b552 --- /dev/null +++ b/tests/baselines/reference/deferredCallbacks.symbols @@ -0,0 +1,627 @@ +//// [tests/cases/compiler/deferredCallbacks.ts] //// + +=== deferredCallbacks.ts === +declare function immediate(cb: () => void): void; +>immediate : Symbol(immediate, Decl(deferredCallbacks.ts, 0, 0)) +>cb : Symbol(cb, Decl(deferredCallbacks.ts, 0, 27)) + +declare function deferred1(deferred cb: () => void): void; +>deferred1 : Symbol(deferred1, Decl(deferredCallbacks.ts, 0, 49)) +>cb : Symbol(cb, Decl(deferredCallbacks.ts, 1, 27)) + +declare function deferred2(/** @deferred */ cb: () => void): void; +>deferred2 : Symbol(deferred2, Decl(deferredCallbacks.ts, 1, 58)) +>cb : Symbol(cb, Decl(deferredCallbacks.ts, 2, 27)) + +declare function deferred3(/** @deferred */ deferred cb: () => void): void; +>deferred3 : Symbol(deferred3, Decl(deferredCallbacks.ts, 2, 66)) +>cb : Symbol(cb, Decl(deferredCallbacks.ts, 3, 27)) + +function f01() { +>f01 : Symbol(f01, Decl(deferredCallbacks.ts, 3, 75)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(deferredCallbacks.ts, 6, 7)) + + immediate(() => { +>immediate : Symbol(immediate, Decl(deferredCallbacks.ts, 0, 0)) + + x = 42; +>x : Symbol(x, Decl(deferredCallbacks.ts, 6, 7)) + + }); + x; // string | number +>x : Symbol(x, Decl(deferredCallbacks.ts, 6, 7)) +} + +function f02() { +>f02 : Symbol(f02, Decl(deferredCallbacks.ts, 11, 1)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(deferredCallbacks.ts, 14, 7)) + + deferred1(() => { +>deferred1 : Symbol(deferred1, Decl(deferredCallbacks.ts, 0, 49)) + + x = 42; +>x : Symbol(x, Decl(deferredCallbacks.ts, 14, 7)) + + }); + x; // string +>x : Symbol(x, Decl(deferredCallbacks.ts, 14, 7)) +} + +function f03() { +>f03 : Symbol(f03, Decl(deferredCallbacks.ts, 19, 1)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(deferredCallbacks.ts, 22, 7)) + + deferred2(() => { +>deferred2 : Symbol(deferred2, Decl(deferredCallbacks.ts, 1, 58)) + + x = 42; +>x : Symbol(x, Decl(deferredCallbacks.ts, 22, 7)) + + }); + x; // string +>x : Symbol(x, Decl(deferredCallbacks.ts, 22, 7)) +} + +function f04() { +>f04 : Symbol(f04, Decl(deferredCallbacks.ts, 27, 1)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(deferredCallbacks.ts, 30, 7)) + + deferred3(() => { +>deferred3 : Symbol(deferred3, Decl(deferredCallbacks.ts, 2, 66)) + + x = 42; +>x : Symbol(x, Decl(deferredCallbacks.ts, 30, 7)) + + }); + x; // string +>x : Symbol(x, Decl(deferredCallbacks.ts, 30, 7)) +} + +// Parameter is considered deferred if one or more overloads defer that parameter + +declare function overloaded(cb: (x: T) => T): void; +>overloaded : Symbol(overloaded, Decl(deferredCallbacks.ts, 35, 1), Decl(deferredCallbacks.ts, 39, 54), Decl(deferredCallbacks.ts, 40, 60)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 39, 28)) +>cb : Symbol(cb, Decl(deferredCallbacks.ts, 39, 31)) +>x : Symbol(x, Decl(deferredCallbacks.ts, 39, 36)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 39, 28)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 39, 28)) + +declare function overloaded(cb: (x: T, y: T) => T): void; +>overloaded : Symbol(overloaded, Decl(deferredCallbacks.ts, 35, 1), Decl(deferredCallbacks.ts, 39, 54), Decl(deferredCallbacks.ts, 40, 60)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 40, 28)) +>cb : Symbol(cb, Decl(deferredCallbacks.ts, 40, 31)) +>x : Symbol(x, Decl(deferredCallbacks.ts, 40, 36)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 40, 28)) +>y : Symbol(y, Decl(deferredCallbacks.ts, 40, 41)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 40, 28)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 40, 28)) + +declare function overloaded(deferred cb: (...args: any) => any): void; +>overloaded : Symbol(overloaded, Decl(deferredCallbacks.ts, 35, 1), Decl(deferredCallbacks.ts, 39, 54), Decl(deferredCallbacks.ts, 40, 60)) +>cb : Symbol(cb, Decl(deferredCallbacks.ts, 41, 28)) +>args : Symbol(args, Decl(deferredCallbacks.ts, 41, 42)) + +function f05() { +>f05 : Symbol(f05, Decl(deferredCallbacks.ts, 41, 70)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(deferredCallbacks.ts, 44, 7)) + + overloaded(() => { +>overloaded : Symbol(overloaded, Decl(deferredCallbacks.ts, 35, 1), Decl(deferredCallbacks.ts, 39, 54), Decl(deferredCallbacks.ts, 40, 60)) + + x = 42; +>x : Symbol(x, Decl(deferredCallbacks.ts, 44, 7)) + + }); + x.length; +>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +>x : Symbol(x, Decl(deferredCallbacks.ts, 44, 7)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +} + +// deferred is permitted on a rest parameter + +declare function invokeImmediate(...args: ((...args: any) => any)[]): void; +>invokeImmediate : Symbol(invokeImmediate, Decl(deferredCallbacks.ts, 49, 1)) +>args : Symbol(args, Decl(deferredCallbacks.ts, 53, 33)) +>args : Symbol(args, Decl(deferredCallbacks.ts, 53, 44)) + +declare function invokeDeferred(deferred ...args: ((...args: any) => any)[]): void; +>invokeDeferred : Symbol(invokeDeferred, Decl(deferredCallbacks.ts, 53, 75)) +>args : Symbol(args, Decl(deferredCallbacks.ts, 54, 32)) +>args : Symbol(args, Decl(deferredCallbacks.ts, 54, 52)) + +function f06() { +>f06 : Symbol(f06, Decl(deferredCallbacks.ts, 54, 83)) + + let a = []; +>a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) + + a.push("abc"); +>a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) + + a; // string[] +>a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) + + invokeImmediate( +>invokeImmediate : Symbol(invokeImmediate, Decl(deferredCallbacks.ts, 49, 1)) + + () => { + a; // string[] +>a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) + + a.push(42); +>a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) + + a; // (string | number)[] +>a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) + + }, + () => { + a; // string[] +>a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) + + a.push(true); +>a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) + + a; // (string | boolean)[] +>a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) + } + ); + a; // (string | number | boolean)[] +>a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) +} + +function f07() { +>f07 : Symbol(f07, Decl(deferredCallbacks.ts, 73, 1)) + + let a = []; +>a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) + + a.push("abc"); +>a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) + + a; // string[] +>a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) + + invokeDeferred( +>invokeDeferred : Symbol(invokeDeferred, Decl(deferredCallbacks.ts, 53, 75)) + + () => { + a; // string[] +>a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) + + a.push(42); +>a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) + + a; // (string | number)[] +>a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) + + }, + () => { + a; // string[] +>a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) + + a.push(true); +>a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) + + a; // (string | boolean)[] +>a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) + } + ); + a; // string[] +>a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) +} + +// deferred modifier must precede public/private/protected/readonly + +class CC { +>CC : Symbol(CC, Decl(deferredCallbacks.ts, 92, 1)) + + constructor(deferred public readonly x: () => void) {} +>x : Symbol(CC.x, Decl(deferredCallbacks.ts, 97, 16)) +} + +// deferred requires parameter to have type that permits functions + +declare function f10(deferred f: () => void): void; +>f10 : Symbol(f10, Decl(deferredCallbacks.ts, 98, 1)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 102, 21)) + +declare function f11(deferred f: Function): void; +>f11 : Symbol(f11, Decl(deferredCallbacks.ts, 102, 51)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 103, 21)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) + +declare function f12(deferred f: any): void; +>f12 : Symbol(f12, Decl(deferredCallbacks.ts, 103, 49)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 104, 21)) + +declare function f13(deferred f: object): void; +>f13 : Symbol(f13, Decl(deferredCallbacks.ts, 104, 44)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 105, 21)) + +declare function f14(deferred f: {}): void; +>f14 : Symbol(f14, Decl(deferredCallbacks.ts, 105, 47)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 106, 21)) + +declare function f15(deferred f: unknown): void; +>f15 : Symbol(f15, Decl(deferredCallbacks.ts, 106, 43)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 107, 21)) + +declare function f16(deferred f: T): void; +>f16 : Symbol(f16, Decl(deferredCallbacks.ts, 107, 48)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 108, 21)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 108, 41)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 108, 21)) + +declare function f17 any>(deferred f: T): void; +>f17 : Symbol(f17, Decl(deferredCallbacks.ts, 108, 62)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 109, 21)) +>args : Symbol(args, Decl(deferredCallbacks.ts, 109, 32)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 109, 54)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 109, 21)) + +declare function f18 void)>(deferred f: T): void; +>f18 : Symbol(f18, Decl(deferredCallbacks.ts, 109, 75)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 110, 21)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 110, 54)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 110, 21)) + +declare function f20(deferred ...funcs: Function[]): void; +>f20 : Symbol(f20, Decl(deferredCallbacks.ts, 110, 75)) +>funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 112, 21)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) + +declare function f21 any)[]>(deferred ...funcs: T): void; +>f21 : Symbol(f21, Decl(deferredCallbacks.ts, 112, 58)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 113, 21)) +>args : Symbol(args, Decl(deferredCallbacks.ts, 113, 33)) +>funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 113, 58)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 113, 21)) + +declare function f22 void))[]>(deferred ...funcs: T): void; +>f22 : Symbol(f22, Decl(deferredCallbacks.ts, 113, 86)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 114, 21)) +>funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 114, 58)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 114, 21)) + +declare function f23 void)[]>(deferred ...funcs: T): void; +>f23 : Symbol(f23, Decl(deferredCallbacks.ts, 114, 86)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 115, 21)) +>funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 115, 58)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 115, 21)) + +declare function f24 void)[]>(deferred ...funcs: T | string[]): void; +>f24 : Symbol(f24, Decl(deferredCallbacks.ts, 115, 86)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 116, 21)) +>funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 116, 47)) +>T : Symbol(T, Decl(deferredCallbacks.ts, 116, 21)) + +declare function f30(deferred f: { foo(): void }): void; +>f30 : Symbol(f30, Decl(deferredCallbacks.ts, 116, 86)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 118, 21)) +>foo : Symbol(foo, Decl(deferredCallbacks.ts, 118, 34)) + +declare function f31(deferred f: number): void; +>f31 : Symbol(f31, Decl(deferredCallbacks.ts, 118, 56)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 119, 21)) + +declare function f32(deferred ...funcs: number[]): void; +>f32 : Symbol(f32, Decl(deferredCallbacks.ts, 119, 47)) +>funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 120, 21)) + +type T10 = (deferred f: () => void) => void; +>T10 : Symbol(T10, Decl(deferredCallbacks.ts, 120, 56)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 122, 12)) + +type T11 = (deferred f: { (): void }) => void; +>T11 : Symbol(T11, Decl(deferredCallbacks.ts, 122, 44)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 123, 12)) + +type T12 = (deferred f: Function) => void; +>T12 : Symbol(T12, Decl(deferredCallbacks.ts, 123, 46)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 124, 12)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) + +type T13 = (deferred f: any) => void; +>T13 : Symbol(T13, Decl(deferredCallbacks.ts, 124, 42)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 125, 12)) + +type T20 = (deferred f: { foo(): void }) => void; +>T20 : Symbol(T20, Decl(deferredCallbacks.ts, 125, 37)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 127, 12)) +>foo : Symbol(foo, Decl(deferredCallbacks.ts, 127, 25)) + +type T21 = (deferred f: number) => void; +>T21 : Symbol(T21, Decl(deferredCallbacks.ts, 127, 49)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 128, 12)) + +type T22 = (deferred ...funcs: number[]) => void; +>T22 : Symbol(T22, Decl(deferredCallbacks.ts, 128, 40)) +>funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 129, 12)) + +type T23 = { deferred x: () => void }; +>T23 : Symbol(T23, Decl(deferredCallbacks.ts, 129, 49)) +>x : Symbol(x, Decl(deferredCallbacks.ts, 130, 12)) + +// deferred modifier is not captured in argument list tuples + +declare function doStuff(deferred f: () => void): void; +>doStuff : Symbol(doStuff, Decl(deferredCallbacks.ts, 130, 38)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 134, 25)) + +declare function recreate(f: (...args: A) => R): (...args: A) => R; +>recreate : Symbol(recreate, Decl(deferredCallbacks.ts, 134, 55)) +>A : Symbol(A, Decl(deferredCallbacks.ts, 136, 26)) +>R : Symbol(R, Decl(deferredCallbacks.ts, 136, 46)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 136, 50)) +>args : Symbol(args, Decl(deferredCallbacks.ts, 136, 54)) +>A : Symbol(A, Decl(deferredCallbacks.ts, 136, 26)) +>R : Symbol(R, Decl(deferredCallbacks.ts, 136, 46)) +>args : Symbol(args, Decl(deferredCallbacks.ts, 136, 74)) +>A : Symbol(A, Decl(deferredCallbacks.ts, 136, 26)) +>R : Symbol(R, Decl(deferredCallbacks.ts, 136, 46)) + +declare function recreateDeferred1(f: (deferred ...args: A) => R): (...args: A) => R; +>recreateDeferred1 : Symbol(recreateDeferred1, Decl(deferredCallbacks.ts, 136, 91)) +>A : Symbol(A, Decl(deferredCallbacks.ts, 137, 35)) +>R : Symbol(R, Decl(deferredCallbacks.ts, 137, 55)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 137, 59)) +>args : Symbol(args, Decl(deferredCallbacks.ts, 137, 63)) +>A : Symbol(A, Decl(deferredCallbacks.ts, 137, 35)) +>R : Symbol(R, Decl(deferredCallbacks.ts, 137, 55)) +>args : Symbol(args, Decl(deferredCallbacks.ts, 137, 92)) +>A : Symbol(A, Decl(deferredCallbacks.ts, 137, 35)) +>R : Symbol(R, Decl(deferredCallbacks.ts, 137, 55)) + +declare function recreateDeferred2(f: (...args: A) => R): (deferred ...args: A) => R; +>recreateDeferred2 : Symbol(recreateDeferred2, Decl(deferredCallbacks.ts, 137, 109)) +>A : Symbol(A, Decl(deferredCallbacks.ts, 138, 35)) +>R : Symbol(R, Decl(deferredCallbacks.ts, 138, 55)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 138, 59)) +>args : Symbol(args, Decl(deferredCallbacks.ts, 138, 63)) +>A : Symbol(A, Decl(deferredCallbacks.ts, 138, 35)) +>R : Symbol(R, Decl(deferredCallbacks.ts, 138, 55)) +>args : Symbol(args, Decl(deferredCallbacks.ts, 138, 83)) +>A : Symbol(A, Decl(deferredCallbacks.ts, 138, 35)) +>R : Symbol(R, Decl(deferredCallbacks.ts, 138, 55)) + +function ff1() { +>ff1 : Symbol(ff1, Decl(deferredCallbacks.ts, 138, 109)) + + let x: string | number; +>x : Symbol(x, Decl(deferredCallbacks.ts, 141, 7)) + + x = 123; +>x : Symbol(x, Decl(deferredCallbacks.ts, 141, 7)) + + doStuff(() => { +>doStuff : Symbol(doStuff, Decl(deferredCallbacks.ts, 130, 38)) + + x = "hi"; +>x : Symbol(x, Decl(deferredCallbacks.ts, 141, 7)) + + }); + x; // number +>x : Symbol(x, Decl(deferredCallbacks.ts, 141, 7)) +} + +function ff2() { +>ff2 : Symbol(ff2, Decl(deferredCallbacks.ts, 147, 1)) + + let y: string | number; +>y : Symbol(y, Decl(deferredCallbacks.ts, 150, 7)) + + y = 123; +>y : Symbol(y, Decl(deferredCallbacks.ts, 150, 7)) + + recreate(doStuff)(() => { +>recreate : Symbol(recreate, Decl(deferredCallbacks.ts, 134, 55)) +>doStuff : Symbol(doStuff, Decl(deferredCallbacks.ts, 130, 38)) + + y = "hi"; +>y : Symbol(y, Decl(deferredCallbacks.ts, 150, 7)) + + }); + y; // string | number +>y : Symbol(y, Decl(deferredCallbacks.ts, 150, 7)) +} + +function ff3() { +>ff3 : Symbol(ff3, Decl(deferredCallbacks.ts, 156, 1)) + + let z: string | number; +>z : Symbol(z, Decl(deferredCallbacks.ts, 159, 7)) + + z = 123; +>z : Symbol(z, Decl(deferredCallbacks.ts, 159, 7)) + + recreateDeferred1(doStuff)(() => { +>recreateDeferred1 : Symbol(recreateDeferred1, Decl(deferredCallbacks.ts, 136, 91)) +>doStuff : Symbol(doStuff, Decl(deferredCallbacks.ts, 130, 38)) + + z = "hi"; +>z : Symbol(z, Decl(deferredCallbacks.ts, 159, 7)) + + }); + z; // string | number +>z : Symbol(z, Decl(deferredCallbacks.ts, 159, 7)) +} + +function ff4() { +>ff4 : Symbol(ff4, Decl(deferredCallbacks.ts, 165, 1)) + + let z: string | number; +>z : Symbol(z, Decl(deferredCallbacks.ts, 168, 7)) + + z = 123; +>z : Symbol(z, Decl(deferredCallbacks.ts, 168, 7)) + + recreateDeferred2(doStuff)(() => { +>recreateDeferred2 : Symbol(recreateDeferred2, Decl(deferredCallbacks.ts, 137, 109)) +>doStuff : Symbol(doStuff, Decl(deferredCallbacks.ts, 130, 38)) + + z = "hi"; +>z : Symbol(z, Decl(deferredCallbacks.ts, 168, 7)) + + }); + z; // number +>z : Symbol(z, Decl(deferredCallbacks.ts, 168, 7)) +} + +// https://github.com/microsoft/TypeScript/issues/11498 + +declare function mystery(cb: () => void): void; +>mystery : Symbol(mystery, Decl(deferredCallbacks.ts, 174, 1)) +>cb : Symbol(cb, Decl(deferredCallbacks.ts, 178, 25)) + +function fx1() { +>fx1 : Symbol(fx1, Decl(deferredCallbacks.ts, 178, 47)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(deferredCallbacks.ts, 181, 7)) + + x; // string +>x : Symbol(x, Decl(deferredCallbacks.ts, 181, 7)) + + mystery(() => { +>mystery : Symbol(mystery, Decl(deferredCallbacks.ts, 174, 1)) + + x = 10; +>x : Symbol(x, Decl(deferredCallbacks.ts, 181, 7)) + + }); + x; // string | number +>x : Symbol(x, Decl(deferredCallbacks.ts, 181, 7)) + + if (x === 10) {} +>x : Symbol(x, Decl(deferredCallbacks.ts, 181, 7)) +} + +// https://github.com/microsoft/TypeScript/issues/15380 + +class Foo { +>Foo : Symbol(Foo, Decl(deferredCallbacks.ts, 188, 1)) + + public bar: string = ""; +>bar : Symbol(Foo.bar, Decl(deferredCallbacks.ts, 192, 11)) +} + +function fx2() { +>fx2 : Symbol(fx2, Decl(deferredCallbacks.ts, 194, 1)) + + let foo: Foo | null = null; +>foo : Symbol(foo, Decl(deferredCallbacks.ts, 197, 5)) +>Foo : Symbol(Foo, Decl(deferredCallbacks.ts, 188, 1)) + + [1].forEach((item) => { +>[1].forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --)) +>item : Symbol(item, Decl(deferredCallbacks.ts, 198, 15)) + + foo = new Foo(); +>foo : Symbol(foo, Decl(deferredCallbacks.ts, 197, 5)) +>Foo : Symbol(Foo, Decl(deferredCallbacks.ts, 188, 1)) + + }); + if (foo) { +>foo : Symbol(foo, Decl(deferredCallbacks.ts, 197, 5)) + + foo.bar; +>foo.bar : Symbol(Foo.bar, Decl(deferredCallbacks.ts, 192, 11)) +>foo : Symbol(foo, Decl(deferredCallbacks.ts, 197, 5)) +>bar : Symbol(Foo.bar, Decl(deferredCallbacks.ts, 192, 11)) + } +} + +// https://github.com/microsoft/TypeScript/issues/57880 + +const call = (f: () => void) => f(); +>call : Symbol(call, Decl(deferredCallbacks.ts, 208, 5)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 208, 14)) +>f : Symbol(f, Decl(deferredCallbacks.ts, 208, 14)) + +const fx3 = () => { +>fx3 : Symbol(fx3, Decl(deferredCallbacks.ts, 210, 5)) + + let a: undefined | number = undefined; +>a : Symbol(a, Decl(deferredCallbacks.ts, 211, 7)) +>undefined : Symbol(undefined) + + call(() => { a = 1; }); +>call : Symbol(call, Decl(deferredCallbacks.ts, 208, 5)) +>a : Symbol(a, Decl(deferredCallbacks.ts, 211, 7)) + + if (a !== undefined) { +>a : Symbol(a, Decl(deferredCallbacks.ts, 211, 7)) +>undefined : Symbol(undefined) + + a.toString(); +>a.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(deferredCallbacks.ts, 211, 7)) +>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) + } +}; + +// https://github.com/microsoft/TypeScript/issues/58291 + +async function execute(onError: (_err: Error | undefined) => void) { +>execute : Symbol(execute, Decl(deferredCallbacks.ts, 216, 2)) +>onError : Symbol(onError, Decl(deferredCallbacks.ts, 220, 23)) +>_err : Symbol(_err, Decl(deferredCallbacks.ts, 220, 33)) +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) + + onError(new Error("a")); +>onError : Symbol(onError, Decl(deferredCallbacks.ts, 220, 23)) +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) +} + +async function run() { +>run : Symbol(run, Decl(deferredCallbacks.ts, 222, 1)) + + let result: boolean = true; +>result : Symbol(result, Decl(deferredCallbacks.ts, 225, 7)) + + await execute(() => { +>execute : Symbol(execute, Decl(deferredCallbacks.ts, 216, 2)) + + result = false; +>result : Symbol(result, Decl(deferredCallbacks.ts, 225, 7)) + + }); + if (result === false) { +>result : Symbol(result, Decl(deferredCallbacks.ts, 225, 7)) + + console.log("error"); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) + } + return result; +>result : Symbol(result, Decl(deferredCallbacks.ts, 225, 7)) +} + diff --git a/tests/baselines/reference/deferredCallbacks.types b/tests/baselines/reference/deferredCallbacks.types new file mode 100644 index 0000000000000..a0cd92c7b6c22 --- /dev/null +++ b/tests/baselines/reference/deferredCallbacks.types @@ -0,0 +1,1035 @@ +//// [tests/cases/compiler/deferredCallbacks.ts] //// + +=== deferredCallbacks.ts === +declare function immediate(cb: () => void): void; +>immediate : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>cb : () => void +> : ^^^^^^ + +declare function deferred1(deferred cb: () => void): void; +>deferred1 : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>cb : () => void +> : ^^^^^^ + +declare function deferred2(/** @deferred */ cb: () => void): void; +>deferred2 : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>cb : () => void +> : ^^^^^^ + +declare function deferred3(/** @deferred */ deferred cb: () => void): void; +>deferred3 : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>cb : () => void +> : ^^^^^^ + +function f01() { +>f01 : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + immediate(() => { +>immediate(() => { x = 42; }) : void +> : ^^^^ +>immediate : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = 42; } : () => void +> : ^^^^^^^^^^ + + x = 42; +>x = 42 : 42 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + }); + x; // string | number +>x : string | number +> : ^^^^^^^^^^^^^^^ +} + +function f02() { +>f02 : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + deferred1(() => { +>deferred1(() => { x = 42; }) : void +> : ^^^^ +>deferred1 : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = 42; } : () => void +> : ^^^^^^^^^^ + + x = 42; +>x = 42 : 42 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + }); + x; // string +>x : string +> : ^^^^^^ +} + +function f03() { +>f03 : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + deferred2(() => { +>deferred2(() => { x = 42; }) : void +> : ^^^^ +>deferred2 : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = 42; } : () => void +> : ^^^^^^^^^^ + + x = 42; +>x = 42 : 42 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + }); + x; // string +>x : string +> : ^^^^^^ +} + +function f04() { +>f04 : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + deferred3(() => { +>deferred3(() => { x = 42; }) : void +> : ^^^^ +>deferred3 : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = 42; } : () => void +> : ^^^^^^^^^^ + + x = 42; +>x = 42 : 42 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + }); + x; // string +>x : string +> : ^^^^^^ +} + +// Parameter is considered deferred if one or more overloads defer that parameter + +declare function overloaded(cb: (x: T) => T): void; +>overloaded : { (cb: (x: T) => T): void; (cb: (x: T_1, y: T_1) => T_1): void; (cb: (...args: any) => any): void; } +> : ^^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ +>cb : (x: T) => T +> : ^ ^^ ^^^^^ +>x : T +> : ^ + +declare function overloaded(cb: (x: T, y: T) => T): void; +>overloaded : { (cb: (x: T_1) => T_1): void; (cb: (x: T, y: T) => T): void; (cb: (...args: any) => any): void; } +> : ^^^^^^^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ +>cb : (x: T, y: T) => T +> : ^ ^^ ^^ ^^ ^^^^^ +>x : T +> : ^ +>y : T +> : ^ + +declare function overloaded(deferred cb: (...args: any) => any): void; +>overloaded : { (cb: (x: T) => T): void; (cb: (x: T, y: T) => T): void; (cb: (...args: any) => any): void; } +> : ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ +>cb : (...args: any) => any +> : ^^^^ ^^ ^^^^^ +>args : any +> : ^^^ + +function f05() { +>f05 : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + overloaded(() => { +>overloaded(() => { x = 42; }) : void +> : ^^^^ +>overloaded : { (cb: (x: T) => T): void; (cb: (x: T, y: T) => T): void; (cb: (...args: any) => any): void; } +> : ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ +>() => { x = 42; } : () => void +> : ^^^^^^^^^^ + + x = 42; +>x = 42 : 42 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + }); + x.length; +>x.length : number +> : ^^^^^^ +>x : string +> : ^^^^^^ +>length : number +> : ^^^^^^ +} + +// deferred is permitted on a rest parameter + +declare function invokeImmediate(...args: ((...args: any) => any)[]): void; +>invokeImmediate : (...args: ((...args: any) => any)[]) => void +> : ^^^^ ^^ ^^^^^ +>args : ((...args: any) => any)[] +> : ^^^^^ ^^ ^^^^^ ^^^ +>args : any +> : ^^^ + +declare function invokeDeferred(deferred ...args: ((...args: any) => any)[]): void; +>invokeDeferred : (...args: ((...args: any) => any)[]) => void +> : ^^^^ ^^ ^^^^^ +>args : ((...args: any) => any)[] +> : ^^^^^ ^^ ^^^^^ ^^^ +>args : any +> : ^^^ + +function f06() { +>f06 : () => void +> : ^^^^^^^^^^ + + let a = []; +>a : any[] +> : ^^^^^ +>[] : never[] +> : ^^^^^^^ + + a.push("abc"); +>a.push("abc") : number +> : ^^^^^^ +>a.push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>a : any[] +> : ^^^^^ +>push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>"abc" : "abc" +> : ^^^^^ + + a; // string[] +>a : string[] +> : ^^^^^^^^ + + invokeImmediate( +>invokeImmediate( () => { a; // string[] a.push(42); a; // (string | number)[] }, () => { a; // string[] a.push(true); a; // (string | boolean)[] } ) : void +> : ^^^^ +>invokeImmediate : (...args: ((...args: any) => any)[]) => void +> : ^^^^ ^^ ^^^^^ + + () => { +>() => { a; // string[] a.push(42); a; // (string | number)[] } : () => void +> : ^^^^^^^^^^ + + a; // string[] +>a : string[] +> : ^^^^^^^^ + + a.push(42); +>a.push(42) : number +> : ^^^^^^ +>a.push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>a : any[] +> : ^^^^^ +>push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + a; // (string | number)[] +>a : (string | number)[] +> : ^^^^^^^^^^^^^^^^^^^ + + }, + () => { +>() => { a; // string[] a.push(true); a; // (string | boolean)[] } : () => void +> : ^^^^^^^^^^ + + a; // string[] +>a : string[] +> : ^^^^^^^^ + + a.push(true); +>a.push(true) : number +> : ^^^^^^ +>a.push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>a : any[] +> : ^^^^^ +>push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>true : true +> : ^^^^ + + a; // (string | boolean)[] +>a : (string | boolean)[] +> : ^^^^^^^^^^^^^^^^^^^^ + } + ); + a; // (string | number | boolean)[] +>a : (string | number | boolean)[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +} + +function f07() { +>f07 : () => void +> : ^^^^^^^^^^ + + let a = []; +>a : any[] +> : ^^^^^ +>[] : never[] +> : ^^^^^^^ + + a.push("abc"); +>a.push("abc") : number +> : ^^^^^^ +>a.push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>a : any[] +> : ^^^^^ +>push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>"abc" : "abc" +> : ^^^^^ + + a; // string[] +>a : string[] +> : ^^^^^^^^ + + invokeDeferred( +>invokeDeferred( () => { a; // string[] a.push(42); a; // (string | number)[] }, () => { a; // string[] a.push(true); a; // (string | boolean)[] } ) : void +> : ^^^^ +>invokeDeferred : (...args: ((...args: any) => any)[]) => void +> : ^^^^ ^^ ^^^^^ + + () => { +>() => { a; // string[] a.push(42); a; // (string | number)[] } : () => void +> : ^^^^^^^^^^ + + a; // string[] +>a : string[] +> : ^^^^^^^^ + + a.push(42); +>a.push(42) : number +> : ^^^^^^ +>a.push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>a : any[] +> : ^^^^^ +>push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + a; // (string | number)[] +>a : (string | number)[] +> : ^^^^^^^^^^^^^^^^^^^ + + }, + () => { +>() => { a; // string[] a.push(true); a; // (string | boolean)[] } : () => void +> : ^^^^^^^^^^ + + a; // string[] +>a : string[] +> : ^^^^^^^^ + + a.push(true); +>a.push(true) : number +> : ^^^^^^ +>a.push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>a : any[] +> : ^^^^^ +>push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>true : true +> : ^^^^ + + a; // (string | boolean)[] +>a : (string | boolean)[] +> : ^^^^^^^^^^^^^^^^^^^^ + } + ); + a; // string[] +>a : string[] +> : ^^^^^^^^ +} + +// deferred modifier must precede public/private/protected/readonly + +class CC { +>CC : CC +> : ^^ + + constructor(deferred public readonly x: () => void) {} +>x : () => void +> : ^^^^^^ +} + +// deferred requires parameter to have type that permits functions + +declare function f10(deferred f: () => void): void; +>f10 : (f: () => void) => void +> : ^ ^^ ^^^^^ +>f : () => void +> : ^^^^^^ + +declare function f11(deferred f: Function): void; +>f11 : (f: Function) => void +> : ^ ^^ ^^^^^ +>f : Function +> : ^^^^^^^^ + +declare function f12(deferred f: any): void; +>f12 : (f: any) => void +> : ^ ^^ ^^^^^ +>f : any +> : ^^^ + +declare function f13(deferred f: object): void; +>f13 : (f: object) => void +> : ^ ^^ ^^^^^ +>f : object +> : ^^^^^^ + +declare function f14(deferred f: {}): void; +>f14 : (f: {}) => void +> : ^ ^^ ^^^^^ +>f : {} +> : ^^ + +declare function f15(deferred f: unknown): void; +>f15 : (f: unknown) => void +> : ^ ^^ ^^^^^ +>f : unknown +> : ^^^^^^^ + +declare function f16(deferred f: T): void; +>f16 : (f: T) => void +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>f : T +> : ^ + +declare function f17 any>(deferred f: T): void; +>f17 : any>(f: T) => void +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>args : any +> : ^^^ +>f : T +> : ^ + +declare function f18 void)>(deferred f: T): void; +>f18 : void)>(f: T) => void +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>f : T +> : ^ + +declare function f20(deferred ...funcs: Function[]): void; +>f20 : (...funcs: Function[]) => void +> : ^^^^ ^^ ^^^^^ +>funcs : Function[] +> : ^^^^^^^^^^ + +declare function f21 any)[]>(deferred ...funcs: T): void; +>f21 : any)[]>(...funcs: T) => void +> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ +>args : any +> : ^^^ +>funcs : T +> : ^ + +declare function f22 void))[]>(deferred ...funcs: T): void; +>f22 : void))[]>(...funcs: T) => void +> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ +>funcs : T +> : ^ + +declare function f23 void)[]>(deferred ...funcs: T): void; +>f23 : void)[]>(...funcs: T) => void +> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ +>funcs : T +> : ^ + +declare function f24 void)[]>(deferred ...funcs: T | string[]): void; +>f24 : void)[]>(...funcs: T | string[]) => void +> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ +>funcs : string[] | T +> : ^^^^^^^^^^^^ + +declare function f30(deferred f: { foo(): void }): void; +>f30 : (f: { foo(): void; }) => void +> : ^ ^^ ^^^^^ +>f : { foo(): void; } +> : ^^^^^^^^^ ^^^ +>foo : () => void +> : ^^^^^^ + +declare function f31(deferred f: number): void; +>f31 : (f: number) => void +> : ^ ^^ ^^^^^ +>f : number +> : ^^^^^^ + +declare function f32(deferred ...funcs: number[]): void; +>f32 : (...funcs: number[]) => void +> : ^^^^ ^^ ^^^^^ +>funcs : number[] +> : ^^^^^^^^ + +type T10 = (deferred f: () => void) => void; +>T10 : T10 +> : ^^^ +>f : () => void +> : ^^^^^^ + +type T11 = (deferred f: { (): void }) => void; +>T11 : T11 +> : ^^^ +>f : () => void +> : ^^^^^^ + +type T12 = (deferred f: Function) => void; +>T12 : T12 +> : ^^^ +>f : Function +> : ^^^^^^^^ + +type T13 = (deferred f: any) => void; +>T13 : T13 +> : ^^^ +>f : any +> : ^^^ + +type T20 = (deferred f: { foo(): void }) => void; +>T20 : T20 +> : ^^^ +>f : { foo(): void; } +> : ^^^^^^^^^ ^^^ +>foo : () => void +> : ^^^^^^ + +type T21 = (deferred f: number) => void; +>T21 : T21 +> : ^^^ +>f : number +> : ^^^^^^ + +type T22 = (deferred ...funcs: number[]) => void; +>T22 : T22 +> : ^^^ +>funcs : number[] +> : ^^^^^^^^ + +type T23 = { deferred x: () => void }; +>T23 : T23 +> : ^^^ +>x : () => void +> : ^^^^^^ + +// deferred modifier is not captured in argument list tuples + +declare function doStuff(deferred f: () => void): void; +>doStuff : (f: () => void) => void +> : ^ ^^ ^^^^^ +>f : () => void +> : ^^^^^^ + +declare function recreate(f: (...args: A) => R): (...args: A) => R; +>recreate : (f: (...args: A) => R) => (...args: A) => R +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>f : (...args: A) => R +> : ^^^^ ^^ ^^^^^ +>args : A +> : ^ +>args : A +> : ^ + +declare function recreateDeferred1(f: (deferred ...args: A) => R): (...args: A) => R; +>recreateDeferred1 : (f: (deferred ...args: A) => R) => (...args: A) => R +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>f : (...args: A) => R +> : ^^^^ ^^ ^^^^^ +>args : A +> : ^ +>args : A +> : ^ + +declare function recreateDeferred2(f: (...args: A) => R): (deferred ...args: A) => R; +>recreateDeferred2 : (f: (...args: A) => R) => (deferred ...args: A) => R +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>f : (...args: A) => R +> : ^^^^ ^^ ^^^^^ +>args : A +> : ^ +>args : A +> : ^ + +function ff1() { +>ff1 : () => void +> : ^^^^^^^^^^ + + let x: string | number; +>x : string | number +> : ^^^^^^^^^^^^^^^ + + x = 123; +>x = 123 : 123 +> : ^^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>123 : 123 +> : ^^^ + + doStuff(() => { +>doStuff(() => { x = "hi"; }) : void +> : ^^^^ +>doStuff : (f: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = "hi"; } : () => void +> : ^^^^^^^^^^ + + x = "hi"; +>x = "hi" : "hi" +> : ^^^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"hi" : "hi" +> : ^^^^ + + }); + x; // number +>x : number +> : ^^^^^^ +} + +function ff2() { +>ff2 : () => void +> : ^^^^^^^^^^ + + let y: string | number; +>y : string | number +> : ^^^^^^^^^^^^^^^ + + y = 123; +>y = 123 : 123 +> : ^^^ +>y : string | number +> : ^^^^^^^^^^^^^^^ +>123 : 123 +> : ^^^ + + recreate(doStuff)(() => { +>recreate(doStuff)(() => { y = "hi"; }) : void +> : ^^^^ +>recreate(doStuff) : (f: () => void) => void +> : ^^^^^^^^^^ ^^^^^^^^^ +>recreate : (f: (...args: A) => R) => (...args: A) => R +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>doStuff : (f: () => void) => void +> : ^ ^^ ^^^^^ +>() => { y = "hi"; } : () => void +> : ^^^^^^^^^^ + + y = "hi"; +>y = "hi" : "hi" +> : ^^^^ +>y : string | number +> : ^^^^^^^^^^^^^^^ +>"hi" : "hi" +> : ^^^^ + + }); + y; // string | number +>y : string | number +> : ^^^^^^^^^^^^^^^ +} + +function ff3() { +>ff3 : () => void +> : ^^^^^^^^^^ + + let z: string | number; +>z : string | number +> : ^^^^^^^^^^^^^^^ + + z = 123; +>z = 123 : 123 +> : ^^^ +>z : string | number +> : ^^^^^^^^^^^^^^^ +>123 : 123 +> : ^^^ + + recreateDeferred1(doStuff)(() => { +>recreateDeferred1(doStuff)(() => { z = "hi"; }) : void +> : ^^^^ +>recreateDeferred1(doStuff) : (f: () => void) => void +> : ^^^^^^^^^^ ^^^^^^^^^ +>recreateDeferred1 : (f: (deferred ...args: A) => R) => (...args: A) => R +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>doStuff : (f: () => void) => void +> : ^ ^^ ^^^^^ +>() => { z = "hi"; } : () => void +> : ^^^^^^^^^^ + + z = "hi"; +>z = "hi" : "hi" +> : ^^^^ +>z : string | number +> : ^^^^^^^^^^^^^^^ +>"hi" : "hi" +> : ^^^^ + + }); + z; // string | number +>z : string | number +> : ^^^^^^^^^^^^^^^ +} + +function ff4() { +>ff4 : () => void +> : ^^^^^^^^^^ + + let z: string | number; +>z : string | number +> : ^^^^^^^^^^^^^^^ + + z = 123; +>z = 123 : 123 +> : ^^^ +>z : string | number +> : ^^^^^^^^^^^^^^^ +>123 : 123 +> : ^^^ + + recreateDeferred2(doStuff)(() => { +>recreateDeferred2(doStuff)(() => { z = "hi"; }) : void +> : ^^^^ +>recreateDeferred2(doStuff) : (f: () => void) => void +> : ^^^^^^^^^^ ^^^^^^^^^ +>recreateDeferred2 : (f: (...args: A) => R) => (deferred ...args: A) => R +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>doStuff : (f: () => void) => void +> : ^ ^^ ^^^^^ +>() => { z = "hi"; } : () => void +> : ^^^^^^^^^^ + + z = "hi"; +>z = "hi" : "hi" +> : ^^^^ +>z : string | number +> : ^^^^^^^^^^^^^^^ +>"hi" : "hi" +> : ^^^^ + + }); + z; // number +>z : number +> : ^^^^^^ +} + +// https://github.com/microsoft/TypeScript/issues/11498 + +declare function mystery(cb: () => void): void; +>mystery : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>cb : () => void +> : ^^^^^^ + +function fx1() { +>fx1 : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + x; // string +>x : string +> : ^^^^^^ + + mystery(() => { +>mystery(() => { x = 10; }) : void +> : ^^^^ +>mystery : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = 10; } : () => void +> : ^^^^^^^^^^ + + x = 10; +>x = 10 : 10 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>10 : 10 +> : ^^ + + }); + x; // string | number +>x : string | number +> : ^^^^^^^^^^^^^^^ + + if (x === 10) {} +>x === 10 : boolean +> : ^^^^^^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>10 : 10 +> : ^^ +} + +// https://github.com/microsoft/TypeScript/issues/15380 + +class Foo { +>Foo : Foo +> : ^^^ + + public bar: string = ""; +>bar : string +> : ^^^^^^ +>"" : "" +> : ^^ +} + +function fx2() { +>fx2 : () => void +> : ^^^^^^^^^^ + + let foo: Foo | null = null; +>foo : Foo | null +> : ^^^^^^^^^^ + + [1].forEach((item) => { +>[1].forEach((item) => { foo = new Foo(); }) : void +> : ^^^^ +>[1].forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void +> : ^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ +>[1] : number[] +> : ^^^^^^^^ +>1 : 1 +> : ^ +>forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void +> : ^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ +>(item) => { foo = new Foo(); } : (item: number) => void +> : ^ ^^^^^^^^^^^^^^^^^ +>item : number +> : ^^^^^^ + + foo = new Foo(); +>foo = new Foo() : Foo +> : ^^^ +>foo : Foo | null +> : ^^^^^^^^^^ +>new Foo() : Foo +> : ^^^ +>Foo : typeof Foo +> : ^^^^^^^^^^ + + }); + if (foo) { +>foo : Foo | null +> : ^^^^^^^^^^ + + foo.bar; +>foo.bar : string +> : ^^^^^^ +>foo : Foo +> : ^^^ +>bar : string +> : ^^^^^^ + } +} + +// https://github.com/microsoft/TypeScript/issues/57880 + +const call = (f: () => void) => f(); +>call : (f: () => void) => void +> : ^ ^^ ^^^^^^^^^ +>(f: () => void) => f() : (f: () => void) => void +> : ^ ^^ ^^^^^^^^^ +>f : () => void +> : ^^^^^^ +>f() : void +> : ^^^^ +>f : () => void +> : ^^^^^^ + +const fx3 = () => { +>fx3 : () => void +> : ^^^^^^^^^^ +>() => { let a: undefined | number = undefined; call(() => { a = 1; }); if (a !== undefined) { a.toString(); }} : () => void +> : ^^^^^^^^^^ + + let a: undefined | number = undefined; +>a : number | undefined +> : ^^^^^^^^^^^^^^^^^^ +>undefined : undefined +> : ^^^^^^^^^ + + call(() => { a = 1; }); +>call(() => { a = 1; }) : void +> : ^^^^ +>call : (f: () => void) => void +> : ^ ^^ ^^^^^^^^^ +>() => { a = 1; } : () => void +> : ^^^^^^^^^^ +>a = 1 : 1 +> : ^ +>a : number | undefined +> : ^^^^^^^^^^^^^^^^^^ +>1 : 1 +> : ^ + + if (a !== undefined) { +>a !== undefined : boolean +> : ^^^^^^^ +>a : number | undefined +> : ^^^^^^^^^^^^^^^^^^ +>undefined : undefined +> : ^^^^^^^^^ + + a.toString(); +>a.toString() : string +> : ^^^^^^ +>a.toString : (radix?: number) => string +> : ^ ^^^ ^^^^^ +>a : number +> : ^^^^^^ +>toString : (radix?: number) => string +> : ^ ^^^ ^^^^^ + } +}; + +// https://github.com/microsoft/TypeScript/issues/58291 + +async function execute(onError: (_err: Error | undefined) => void) { +>execute : (onError: (_err: Error | undefined) => void) => Promise +> : ^ ^^ ^^^^^^^^^^^^^^^^^^ +>onError : (_err: Error | undefined) => void +> : ^ ^^ ^^^^^ +>_err : Error | undefined +> : ^^^^^^^^^^^^^^^^^ + + onError(new Error("a")); +>onError(new Error("a")) : void +> : ^^^^ +>onError : (_err: Error | undefined) => void +> : ^ ^^ ^^^^^ +>new Error("a") : Error +> : ^^^^^ +>Error : ErrorConstructor +> : ^^^^^^^^^^^^^^^^ +>"a" : "a" +> : ^^^ +} + +async function run() { +>run : () => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^ + + let result: boolean = true; +>result : boolean +> : ^^^^^^^ +>true : true +> : ^^^^ + + await execute(() => { +>await execute(() => { result = false; }) : void +> : ^^^^ +>execute(() => { result = false; }) : Promise +> : ^^^^^^^^^^^^^ +>execute : (onError: (_err: Error | undefined) => void) => Promise +> : ^ ^^ ^^^^^^^^^^^^^^^^^^ +>() => { result = false; } : () => void +> : ^^^^^^^^^^ + + result = false; +>result = false : false +> : ^^^^^ +>result : boolean +> : ^^^^^^^ +>false : false +> : ^^^^^ + + }); + if (result === false) { +>result === false : boolean +> : ^^^^^^^ +>result : boolean +> : ^^^^^^^ +>false : false +> : ^^^^^ + + console.log("error"); +>console.log("error") : void +> : ^^^^ +>console.log : (...data: any[]) => void +> : ^^^^ ^^ ^^^^^ +>console : Console +> : ^^^^^^^ +>log : (...data: any[]) => void +> : ^^^^ ^^ ^^^^^ +>"error" : "error" +> : ^^^^^^^ + } + return result; +>result : boolean +> : ^^^^^^^ +} + diff --git a/tests/cases/compiler/deferredCallbacks.ts b/tests/cases/compiler/deferredCallbacks.ts new file mode 100644 index 0000000000000..33f324704c2e9 --- /dev/null +++ b/tests/cases/compiler/deferredCallbacks.ts @@ -0,0 +1,238 @@ +// @strict: true +// @declaration: true +// @target: esnext + +declare function immediate(cb: () => void): void; +declare function deferred1(deferred cb: () => void): void; +declare function deferred2(/** @deferred */ cb: () => void): void; +declare function deferred3(/** @deferred */ deferred cb: () => void): void; + +function f01() { + let x: string | number = "OK"; + immediate(() => { + x = 42; + }); + x; // string | number +} + +function f02() { + let x: string | number = "OK"; + deferred1(() => { + x = 42; + }); + x; // string +} + +function f03() { + let x: string | number = "OK"; + deferred2(() => { + x = 42; + }); + x; // string +} + +function f04() { + let x: string | number = "OK"; + deferred3(() => { + x = 42; + }); + x; // string +} + +// Parameter is considered deferred if one or more overloads defer that parameter + +declare function overloaded(cb: (x: T) => T): void; +declare function overloaded(cb: (x: T, y: T) => T): void; +declare function overloaded(deferred cb: (...args: any) => any): void; + +function f05() { + let x: string | number = "OK"; + overloaded(() => { + x = 42; + }); + x.length; +} + +// deferred is permitted on a rest parameter + +declare function invokeImmediate(...args: ((...args: any) => any)[]): void; +declare function invokeDeferred(deferred ...args: ((...args: any) => any)[]): void; + +function f06() { + let a = []; + a.push("abc"); + a; // string[] + invokeImmediate( + () => { + a; // string[] + a.push(42); + a; // (string | number)[] + }, + () => { + a; // string[] + a.push(true); + a; // (string | boolean)[] + } + ); + a; // (string | number | boolean)[] +} + +function f07() { + let a = []; + a.push("abc"); + a; // string[] + invokeDeferred( + () => { + a; // string[] + a.push(42); + a; // (string | number)[] + }, + () => { + a; // string[] + a.push(true); + a; // (string | boolean)[] + } + ); + a; // string[] +} + +// deferred modifier must precede public/private/protected/readonly + +class CC { + constructor(deferred public readonly x: () => void) {} +} + +// deferred requires parameter to have type that permits functions + +declare function f10(deferred f: () => void): void; +declare function f11(deferred f: Function): void; +declare function f12(deferred f: any): void; +declare function f13(deferred f: object): void; +declare function f14(deferred f: {}): void; +declare function f15(deferred f: unknown): void; +declare function f16(deferred f: T): void; +declare function f17 any>(deferred f: T): void; +declare function f18 void)>(deferred f: T): void; + +declare function f20(deferred ...funcs: Function[]): void; +declare function f21 any)[]>(deferred ...funcs: T): void; +declare function f22 void))[]>(deferred ...funcs: T): void; +declare function f23 void)[]>(deferred ...funcs: T): void; +declare function f24 void)[]>(deferred ...funcs: T | string[]): void; + +declare function f30(deferred f: { foo(): void }): void; +declare function f31(deferred f: number): void; +declare function f32(deferred ...funcs: number[]): void; + +type T10 = (deferred f: () => void) => void; +type T11 = (deferred f: { (): void }) => void; +type T12 = (deferred f: Function) => void; +type T13 = (deferred f: any) => void; + +type T20 = (deferred f: { foo(): void }) => void; +type T21 = (deferred f: number) => void; +type T22 = (deferred ...funcs: number[]) => void; +type T23 = { deferred x: () => void }; + +// deferred modifier is not captured in argument list tuples + +declare function doStuff(deferred f: () => void): void; + +declare function recreate(f: (...args: A) => R): (...args: A) => R; +declare function recreateDeferred1(f: (deferred ...args: A) => R): (...args: A) => R; +declare function recreateDeferred2(f: (...args: A) => R): (deferred ...args: A) => R; + +function ff1() { + let x: string | number; + x = 123; + doStuff(() => { + x = "hi"; + }); + x; // number +} + +function ff2() { + let y: string | number; + y = 123; + recreate(doStuff)(() => { + y = "hi"; + }); + y; // string | number +} + +function ff3() { + let z: string | number; + z = 123; + recreateDeferred1(doStuff)(() => { + z = "hi"; + }); + z; // string | number +} + +function ff4() { + let z: string | number; + z = 123; + recreateDeferred2(doStuff)(() => { + z = "hi"; + }); + z; // number +} + +// https://github.com/microsoft/TypeScript/issues/11498 + +declare function mystery(cb: () => void): void; + +function fx1() { + let x: string | number = "OK"; + x; // string + mystery(() => { + x = 10; + }); + x; // string | number + if (x === 10) {} +} + +// https://github.com/microsoft/TypeScript/issues/15380 + +class Foo { + public bar: string = ""; +} + +function fx2() { + let foo: Foo | null = null; + [1].forEach((item) => { + foo = new Foo(); + }); + if (foo) { + foo.bar; + } +} + +// https://github.com/microsoft/TypeScript/issues/57880 + +const call = (f: () => void) => f(); + +const fx3 = () => { + let a: undefined | number = undefined; + call(() => { a = 1; }); + if (a !== undefined) { + a.toString(); + } +}; + +// https://github.com/microsoft/TypeScript/issues/58291 + +async function execute(onError: (_err: Error | undefined) => void) { + onError(new Error("a")); +} + +async function run() { + let result: boolean = true; + await execute(() => { + result = false; + }); + if (result === false) { + console.log("error"); + } + return result; +} From 5ae48a223af04b060175760cf24fdc5a81827b4b Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 8 Aug 2024 10:25:21 -0700 Subject: [PATCH 24/30] Switch from 'deferred' modifier to 'immediate' modifier --- src/compiler/checker.ts | 24 ++++++++++----------- src/compiler/diagnosticMessages.json | 4 ++-- src/compiler/factory/nodeFactory.ts | 14 ++++++------ src/compiler/factory/nodeTests.ts | 6 +++--- src/compiler/parser.ts | 4 ++-- src/compiler/program.ts | 2 +- src/compiler/scanner.ts | 6 +++--- src/compiler/transformers/ts.ts | 2 +- src/compiler/types.ts | 32 ++++++++++++++-------------- src/compiler/utilities.ts | 8 +++---- src/compiler/utilitiesPublic.ts | 16 +++++++------- 11 files changed, 59 insertions(+), 59 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index be73a19802c75..65d0f579f4460 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -28554,7 +28554,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // circularities. Instead, we simply check if any signature has a deferred callback marker in the // particular argument position. signatures ??= getSignaturesOfType(getTypeOfExpression(flow.node.expression), SignatureKind.Call); - if (!some(signatures, sig => !!(getModifiersAtPosition(sig, i) & (ModifierFlags.Deferred | ModifierFlags.JSDocDeferred)))) { + if (some(signatures, sig => !!(getModifiersAtPosition(sig, i) & (ModifierFlags.Immediate | ModifierFlags.JSDocImmediate)))) { const lambdaType = getTypeFromFlowType(getTypeAtFlowNode(lambda.returnFlowNode)); if (lambdaType !== initialType) { lambdaTypes ??= [initialType]; @@ -41140,10 +41140,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (node.dotDotDotToken && !isBindingPattern(node.name) && !isTypeAssignableTo(getReducedType(getTypeOfSymbol(node.symbol)), anyReadonlyArrayType)) { error(node, Diagnostics.A_rest_parameter_must_be_of_an_array_type); } - if (hasEffectiveModifier(node, ModifierFlags.Deferred | ModifierFlags.JSDocDeferred)) { + if (hasEffectiveModifier(node, ModifierFlags.Immediate | ModifierFlags.JSDocImmediate)) { const funcType = node.dotDotDotToken ? createArrayType(globalFunctionType, /*readonly*/ true) : globalFunctionType; if (!areTypesComparable(getTypeOfSymbol(node.symbol), funcType)) { - error(node, Diagnostics.A_deferred_parameter_must_have_a_type_that_permits_functions); + error(node, Diagnostics.An_immediate_parameter_must_have_a_type_that_permits_functions); } } } @@ -51025,26 +51025,26 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { break; } - case SyntaxKind.DeferredKeyword: + case SyntaxKind.ImmediateKeyword: if (node.kind !== SyntaxKind.Parameter) { - return grammarErrorOnNode(modifier, Diagnostics.deferred_modifier_can_only_appear_on_a_parameter_declaration); + return grammarErrorOnNode(modifier, Diagnostics.immediate_modifier_can_only_appear_on_a_parameter_declaration); } - if (flags & ModifierFlags.Deferred) { - return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "deferred"); + if (flags & ModifierFlags.Immediate) { + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "immediate"); } if (flags & ModifierFlags.Public) { - return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "deferred", "public"); + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "immediate", "public"); } if (flags & ModifierFlags.Protected) { - return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "deferred", "protected"); + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "immediate", "protected"); } if (flags & ModifierFlags.Private) { - return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "deferred", "private"); + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "immediate", "private"); } if (flags & ModifierFlags.Readonly) { - return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "deferred", "readonly"); + return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "immediate", "readonly"); } - flags |= ModifierFlags.Deferred; + flags |= ModifierFlags.Immediate; break; } } diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 568aeb56a1287..1da5558b1880c 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -971,7 +971,7 @@ "category": "Error", "code": 1293 }, - "'deferred' modifier can only appear on a parameter declaration.": { + "'immediate' modifier can only appear on a parameter declaration.": { "category": "Error", "code": 1294 }, @@ -3944,7 +3944,7 @@ "category": "Error", "code": 2873 }, - "A 'deferred' parameter must have a type that permits functions.": { + "An 'immediate' parameter must have a type that permits functions.": { "category": "Error", "code": 2874 }, diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts index 088d2cbf27aa0..883036dc1e372 100644 --- a/src/compiler/factory/nodeFactory.ts +++ b/src/compiler/factory/nodeFactory.ts @@ -222,10 +222,10 @@ import { JSDocCallbackTag, JSDocClassTag, JSDocComment, - JSDocDeferredTag, JSDocDeprecatedTag, JSDocEnumTag, JSDocFunctionType, + JSDocImmediateTag, JSDocImplementsTag, JSDocImportTag, JSDocLink, @@ -939,11 +939,11 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode get updateJSDocDeprecatedTag() { return getJSDocSimpleTagUpdateFunction(SyntaxKind.JSDocDeprecatedTag); }, - get createJSDocDeferredTag() { - return getJSDocSimpleTagCreateFunction(SyntaxKind.JSDocDeferredTag); + get createJSDocImmediateTag() { + return getJSDocSimpleTagCreateFunction(SyntaxKind.JSDocImmediateTag); }, - get updateJSDocDeferredTag() { - return getJSDocSimpleTagUpdateFunction(SyntaxKind.JSDocDeferredTag); + get updateJSDocImmediateTag() { + return getJSDocSimpleTagUpdateFunction(SyntaxKind.JSDocImmediateTag); }, get createJSDocThrowsTag() { return getJSDocTypeLikeTagCreateFunction(SyntaxKind.JSDocThrowsTag); @@ -1478,7 +1478,7 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode case SyntaxKind.ReadonlyKeyword: case SyntaxKind.AbstractKeyword: case SyntaxKind.DeclareKeyword: - case SyntaxKind.DeferredKeyword: + case SyntaxKind.ImmediateKeyword: case SyntaxKind.ConstKeyword: case SyntaxKind.AnyKeyword: case SyntaxKind.NumberKeyword: @@ -1563,7 +1563,7 @@ export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNode if (flags & ModifierFlags.Ambient) result.push(createModifier(SyntaxKind.DeclareKeyword)); if (flags & ModifierFlags.Default) result.push(createModifier(SyntaxKind.DefaultKeyword)); if (flags & ModifierFlags.Const) result.push(createModifier(SyntaxKind.ConstKeyword)); - if (flags & ModifierFlags.Deferred) result.push(createModifier(SyntaxKind.DeferredKeyword)); + if (flags & ModifierFlags.Immediate) result.push(createModifier(SyntaxKind.ImmediateKeyword)); if (flags & ModifierFlags.Public) result.push(createModifier(SyntaxKind.PublicKeyword)); if (flags & ModifierFlags.Private) result.push(createModifier(SyntaxKind.PrivateKeyword)); if (flags & ModifierFlags.Protected) result.push(createModifier(SyntaxKind.ProtectedKeyword)); diff --git a/src/compiler/factory/nodeTests.ts b/src/compiler/factory/nodeTests.ts index cd8d8ede72f34..654c6bbc5daf3 100644 --- a/src/compiler/factory/nodeTests.ts +++ b/src/compiler/factory/nodeTests.ts @@ -87,10 +87,10 @@ import { JSDocAuthorTag, JSDocCallbackTag, JSDocClassTag, - JSDocDeferredTag, JSDocDeprecatedTag, JSDocEnumTag, JSDocFunctionType, + JSDocImmediateTag, JSDocImplementsTag, JSDocImportTag, JSDocLink, @@ -1138,8 +1138,8 @@ export function isJSDocDeprecatedTag(node: Node): node is JSDocDeprecatedTag { return node.kind === SyntaxKind.JSDocDeprecatedTag; } -export function isJSDocDeferredTag(node: Node): node is JSDocDeferredTag { - return node.kind === SyntaxKind.JSDocDeferredTag; +export function isJSDocImmediateTag(node: Node): node is JSDocImmediateTag { + return node.kind === SyntaxKind.JSDocImmediateTag; } export function isJSDocSeeTag(node: Node): node is JSDocSeeTag { diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 32d49f158eb5f..d9fa26d3b4520 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -9081,8 +9081,8 @@ namespace Parser { hasDeprecatedTag = true; tag = parseSimpleTag(start, factory.createJSDocDeprecatedTag, tagName, margin, indentText); break; - case "deferred": - tag = parseSimpleTag(start, factory.createJSDocDeferredTag, tagName, margin, indentText); + case "immediate": + tag = parseSimpleTag(start, factory.createJSDocImmediateTag, tagName, margin, indentText); break; case "this": tag = parseThisTag(start, tagName, margin, indentText); diff --git a/src/compiler/program.ts b/src/compiler/program.ts index e17eb299e2e41..878f88e481d0a 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -3342,7 +3342,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg case SyntaxKind.ProtectedKeyword: case SyntaxKind.ReadonlyKeyword: case SyntaxKind.DeclareKeyword: - case SyntaxKind.DeferredKeyword: + case SyntaxKind.ImmediateKeyword: case SyntaxKind.AbstractKeyword: case SyntaxKind.OverrideKeyword: case SyntaxKind.InKeyword: diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index a841fca417808..1800e8dcb9b31 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -150,7 +150,6 @@ export const textToKeywordObj: MapLike = { debugger: SyntaxKind.DebuggerKeyword, declare: SyntaxKind.DeclareKeyword, default: SyntaxKind.DefaultKeyword, - deferred: SyntaxKind.DeferredKeyword, delete: SyntaxKind.DeleteKeyword, do: SyntaxKind.DoKeyword, else: SyntaxKind.ElseKeyword, @@ -164,6 +163,7 @@ export const textToKeywordObj: MapLike = { function: SyntaxKind.FunctionKeyword, get: SyntaxKind.GetKeyword, if: SyntaxKind.IfKeyword, + immediate: SyntaxKind.ImmediateKeyword, implements: SyntaxKind.ImplementsKeyword, import: SyntaxKind.ImportKeyword, in: SyntaxKind.InKeyword, @@ -352,7 +352,7 @@ const commentDirectiveRegExSingleLine = /^\/\/\/?\s*@(ts-expect-error|ts-ignore) */ const commentDirectiveRegExMultiLine = /^(?:\/|\*)*\s*@(ts-expect-error|ts-ignore)/; -const jsDocSeeOrLinkOrDeferred = /@(?:see|link|deferred)/i; +const jsDocSeeOrLinkOrImmediate = /@(?:see|link|immediate)/i; function lookupInUnicodeMap(code: number, map: readonly number[]): boolean { // Bail out quickly if it couldn't possibly be in the map. @@ -2397,7 +2397,7 @@ export function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean return false; } - return jsDocSeeOrLinkOrDeferred.test(text.slice(fullStartPos, pos)); + return jsDocSeeOrLinkOrImmediate.test(text.slice(fullStartPos, pos)); } function reScanInvalidIdentifier(): SyntaxKind { diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts index 145e4fd3d0f88..5ab6ea370c0de 100644 --- a/src/compiler/transformers/ts.ts +++ b/src/compiler/transformers/ts.ts @@ -661,7 +661,7 @@ export function transformTypeScript(context: TransformationContext) { case SyntaxKind.OverrideKeyword: case SyntaxKind.ConstKeyword: case SyntaxKind.DeclareKeyword: - case SyntaxKind.DeferredKeyword: + case SyntaxKind.ImmediateKeyword: case SyntaxKind.ReadonlyKeyword: case SyntaxKind.InKeyword: case SyntaxKind.OutKeyword: diff --git a/src/compiler/types.ts b/src/compiler/types.ts index bd0cde013e2b2..f710a4af1cff1 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -195,8 +195,8 @@ export const enum SyntaxKind { BooleanKeyword, ConstructorKeyword, DeclareKeyword, - DeferredKeyword, GetKeyword, + ImmediateKeyword, InferKeyword, IntrinsicKeyword, IsKeyword, @@ -420,7 +420,7 @@ export const enum SyntaxKind { JSDocImplementsTag, JSDocAuthorTag, JSDocDeprecatedTag, - JSDocDeferredTag, + JSDocImmediateTag, JSDocClassTag, JSDocPublicTag, JSDocPrivateTag, @@ -599,7 +599,6 @@ export type KeywordSyntaxKind = | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword - | SyntaxKind.DeferredKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword @@ -614,6 +613,7 @@ export type KeywordSyntaxKind = | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword + | SyntaxKind.ImmediateKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword @@ -671,8 +671,8 @@ export type ModifierSyntaxKind = | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword - | SyntaxKind.DeferredKeyword | SyntaxKind.ExportKeyword + | SyntaxKind.ImmediateKeyword | SyntaxKind.InKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword @@ -869,11 +869,11 @@ export const enum ModifierFlags { In = 1 << 13, // Contravariance modifier Out = 1 << 14, // Covariance modifier Decorator = 1 << 15, // Contains a decorator. - Deferred = 1 << 16, // Parameter + Immediate = 1 << 16, // Parameter // JSDoc-only modifiers Deprecated = 1 << 17, // Deprecated tag. - JSDocDeferred = 1 << 18, // Parameter + JSDocImmediate = 1 << 18, // Parameter // Cache-only JSDoc-modifiers. Should match order of Syntactic/JSDoc modifiers, above. /** @internal */ JSDocPublic = 1 << 23, // if this value changes, `selectEffectiveModifierFlags` must change accordingly @@ -883,10 +883,10 @@ export const enum ModifierFlags { /** @internal */ JSDocOverride = 1 << 27, /** @internal */ SyntacticOrJSDocModifiers = Public | Private | Protected | Readonly | Override, - /** @internal */ SyntacticOnlyModifiers = Export | Ambient | Abstract | Static | Accessor | Async | Default | Const | In | Out | Decorator | Deferred, + /** @internal */ SyntacticOnlyModifiers = Export | Ambient | Abstract | Static | Accessor | Async | Default | Const | In | Out | Decorator | Immediate, /** @internal */ SyntacticModifiers = SyntacticOrJSDocModifiers | SyntacticOnlyModifiers, /** @internal */ JSDocCacheOnlyModifiers = JSDocPublic | JSDocPrivate | JSDocProtected | JSDocReadonly | JSDocOverride, - /** @internal */ JSDocOnlyModifiers = Deprecated | JSDocDeferred, + /** @internal */ JSDocOnlyModifiers = Deprecated | JSDocImmediate, /** @internal */ NonCacheOnlyModifiers = SyntacticOrJSDocModifiers | SyntacticOnlyModifiers | JSDocOnlyModifiers, HasComputedJSDocModifiers = 1 << 28, // Indicates the computed modifier flags include modifiers from JSDoc. @@ -897,9 +897,9 @@ export const enum ModifierFlags { ParameterPropertyModifier = AccessibilityModifier | Readonly | Override, NonPublicAccessibilityModifier = Private | Protected, - TypeScriptModifier = Ambient | Public | Private | Protected | Readonly | Abstract | Const | Override | In | Out | Deferred, + TypeScriptModifier = Ambient | Public | Private | Protected | Readonly | Abstract | Const | Override | In | Out | Immediate, ExportDefault = Export | Default, - All = Export | Ambient | Public | Private | Protected | Static | Readonly | Abstract | Accessor | Async | Default | Const | Deprecated | Override | In | Out | Deferred | Decorator, + All = Export | Ambient | Public | Private | Protected | Static | Readonly | Abstract | Accessor | Async | Default | Const | Deprecated | Override | In | Out | Immediate | Decorator, Modifier = All & ~Decorator, } @@ -1636,8 +1636,8 @@ export type AsyncKeyword = ModifierToken; export type ConstKeyword = ModifierToken; export type DeclareKeyword = ModifierToken; export type DefaultKeyword = ModifierToken; -export type DeferredKeyword = ModifierToken; export type ExportKeyword = ModifierToken; +export type ImmediateKeyword = ModifierToken; export type InKeyword = ModifierToken; export type PrivateKeyword = ModifierToken; export type ProtectedKeyword = ModifierToken; @@ -1654,8 +1654,8 @@ export type Modifier = | ConstKeyword | DeclareKeyword | DefaultKeyword - | DeferredKeyword | ExportKeyword + | ImmediateKeyword | InKeyword | PrivateKeyword | ProtectedKeyword @@ -3994,8 +3994,8 @@ export interface JSDocDeprecatedTag extends JSDocTag { kind: SyntaxKind.JSDocDeprecatedTag; } -export interface JSDocDeferredTag extends JSDocTag { - kind: SyntaxKind.JSDocDeferredTag; +export interface JSDocImmediateTag extends JSDocTag { + kind: SyntaxKind.JSDocImmediateTag; } export interface JSDocClassTag extends JSDocTag { @@ -9057,8 +9057,8 @@ export interface NodeFactory { updateJSDocUnknownTag(node: JSDocUnknownTag, tagName: Identifier, comment: string | NodeArray | undefined): JSDocUnknownTag; createJSDocDeprecatedTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeprecatedTag; updateJSDocDeprecatedTag(node: JSDocDeprecatedTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeprecatedTag; - createJSDocDeferredTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeferredTag; - updateJSDocDeferredTag(node: JSDocDeferredTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeferredTag; + createJSDocImmediateTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocImmediateTag; + updateJSDocImmediateTag(node: JSDocImmediateTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocImmediateTag; createJSDocOverrideTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocOverrideTag; updateJSDocOverrideTag(node: JSDocOverrideTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocOverrideTag; createJSDocThrowsTag(tagName: Identifier, typeExpression: JSDocTypeExpression | undefined, comment?: string | NodeArray): JSDocThrowsTag; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 7e9f1cee6c13f..7f3676f6e5960 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -169,8 +169,8 @@ import { getDirectoryPath, getImpliedNodeFormatForEmitWorker, getJSDocAugmentsTag, - getJSDocDeferredTagNoCache, getJSDocDeprecatedTagNoCache, + getJSDocImmediateTagNoCache, getJSDocImplementsTags, getJSDocOverrideTagNoCache, getJSDocParameterTags, @@ -7108,7 +7108,7 @@ function getRawJSDocModifierFlagsNoCache(node: Node): ModifierFlags { } } if (!isParameter(node) && getJSDocDeprecatedTagNoCache(node)) flags |= ModifierFlags.Deprecated; - if (getJSDocDeferredTagNoCache(node)) flags |= ModifierFlags.JSDocDeferred; + if (getJSDocImmediateTagNoCache(node)) flags |= ModifierFlags.JSDocImmediate; } return flags; @@ -7198,8 +7198,8 @@ export function modifierToFlag(token: SyntaxKind): ModifierFlags { return ModifierFlags.In; case SyntaxKind.OutKeyword: return ModifierFlags.Out; - case SyntaxKind.DeferredKeyword: - return ModifierFlags.Deferred; + case SyntaxKind.ImmediateKeyword: + return ModifierFlags.Immediate; case SyntaxKind.Decorator: return ModifierFlags.Decorator; } diff --git a/src/compiler/utilitiesPublic.ts b/src/compiler/utilitiesPublic.ts index 8b0e397e7c51a..c441d03d641ac 100644 --- a/src/compiler/utilitiesPublic.ts +++ b/src/compiler/utilitiesPublic.ts @@ -137,10 +137,10 @@ import { isJSDoc, isJSDocAugmentsTag, isJSDocClassTag, - isJSDocDeferredTag, isJSDocDeprecatedTag, isJSDocEnumTag, isJSDocFunctionType, + isJSDocImmediateTag, isJSDocImplementsTag, isJSDocOverloadTag, isJSDocOverrideTag, @@ -182,9 +182,9 @@ import { JSDocClassTag, JSDocComment, JSDocContainer, - JSDocDeferredTag, JSDocDeprecatedTag, JSDocEnumTag, + JSDocImmediateTag, JSDocImplementsTag, JSDocLink, JSDocLinkCode, @@ -1163,14 +1163,14 @@ export function getJSDocDeprecatedTagNoCache(node: Node): JSDocDeprecatedTag | u return getFirstJSDocTag(node, isJSDocDeprecatedTag, /*noCache*/ true); } -/** Gets the JSDoc deferred tag for the node if present */ -export function getJSDocDeferredTag(node: Node): JSDocDeferredTag | undefined { - return getFirstJSDocTag(node, isJSDocDeferredTag); +/** Gets the JSDoc immediate tag for the node if present */ +export function getJSDocImmediateTag(node: Node): JSDocImmediateTag | undefined { + return getFirstJSDocTag(node, isJSDocImmediateTag); } /** @internal */ -export function getJSDocDeferredTagNoCache(node: Node): JSDocDeferredTag | undefined { - return getFirstJSDocTag(node, isJSDocDeferredTag, /*noCache*/ true); +export function getJSDocImmediateTagNoCache(node: Node): JSDocImmediateTag | undefined { + return getFirstJSDocTag(node, isJSDocImmediateTag, /*noCache*/ true); } /** Gets the JSDoc enum tag for the node if present */ @@ -1609,8 +1609,8 @@ export function isModifierKind(token: SyntaxKind): token is Modifier["kind"] { case SyntaxKind.ConstKeyword: case SyntaxKind.DeclareKeyword: case SyntaxKind.DefaultKeyword: - case SyntaxKind.DeferredKeyword: case SyntaxKind.ExportKeyword: + case SyntaxKind.ImmediateKeyword: case SyntaxKind.InKeyword: case SyntaxKind.PublicKeyword: case SyntaxKind.PrivateKeyword: From c16fc38d3034a5355101cbbd2d0dba2d7df7d447 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 8 Aug 2024 10:25:47 -0700 Subject: [PATCH 25/30] Update library types --- src/lib/es2015.collection.d.ts | 8 +- src/lib/es2015.core.d.ts | 14 +- src/lib/es2015.iterable.d.ts | 20 +- src/lib/es2018.promise.d.ts | 2 +- src/lib/es2019.array.d.ts | 4 +- src/lib/es2020.bigint.d.ts | 52 ++--- src/lib/es2023.array.d.ts | 104 +++++----- src/lib/es5.d.ts | 336 ++++++++++++++++----------------- src/lib/esnext.array.d.ts | 2 +- src/lib/esnext.collection.d.ts | 2 +- src/lib/esnext.iterator.d.ts | 24 +-- src/lib/esnext.object.d.ts | 2 +- 12 files changed, 285 insertions(+), 285 deletions(-) diff --git a/src/lib/es2015.collection.d.ts b/src/lib/es2015.collection.d.ts index e88f0d4c3b405..86c2f0c27bb29 100644 --- a/src/lib/es2015.collection.d.ts +++ b/src/lib/es2015.collection.d.ts @@ -7,7 +7,7 @@ interface Map { /** * Executes a provided function once per each key/value pair in the Map, in insertion order. */ - forEach(callbackfn: (value: V, key: K, map: Map) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: V, key: K, map: Map) => void, thisArg?: any): void; /** * Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map. * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned. @@ -35,7 +35,7 @@ interface MapConstructor { declare var Map: MapConstructor; interface ReadonlyMap { - forEach(callbackfn: (value: V, key: K, map: ReadonlyMap) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: V, key: K, map: ReadonlyMap) => void, thisArg?: any): void; get(key: K): V | undefined; has(key: K): boolean; readonly size: number; @@ -83,7 +83,7 @@ interface Set { /** * Executes a provided function once per each value in the Set object, in insertion order. */ - forEach(callbackfn: (value: T, value2: T, set: Set) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: T, value2: T, set: Set) => void, thisArg?: any): void; /** * @returns a boolean indicating whether an element with the specified value exists in the Set or not. */ @@ -101,7 +101,7 @@ interface SetConstructor { declare var Set: SetConstructor; interface ReadonlySet { - forEach(callbackfn: (value: T, value2: T, set: ReadonlySet) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: T, value2: T, set: ReadonlySet) => void, thisArg?: any): void; has(value: T): boolean; readonly size: number; } diff --git a/src/lib/es2015.core.d.ts b/src/lib/es2015.core.d.ts index fda087bb55126..09f0f88e28c78 100644 --- a/src/lib/es2015.core.d.ts +++ b/src/lib/es2015.core.d.ts @@ -8,8 +8,8 @@ interface Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined; - find(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined; + find(/** @immediate */ predicate: (value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined; + find(/** @immediate */ predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -20,7 +20,7 @@ interface Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): number; + findIndex(/** @immediate */ predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): number; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -59,7 +59,7 @@ interface ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; + from(arrayLike: ArrayLike, /** @immediate */ mapfn: (v: T, k: number) => U, thisArg?: any): U[]; /** * Returns a new array from a set of elements. @@ -331,8 +331,8 @@ interface ReadonlyArray { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: T, index: number, obj: readonly T[]) => value is S, thisArg?: any): S | undefined; - find(predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): T | undefined; + find(/** @immediate */ predicate: (value: T, index: number, obj: readonly T[]) => value is S, thisArg?: any): S | undefined; + find(/** @immediate */ predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): T | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -343,7 +343,7 @@ interface ReadonlyArray { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): number; + findIndex(/** @immediate */ predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): number; toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; } diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts index 50e2277c533e1..dbf6e572fe07d 100644 --- a/src/lib/es2015.iterable.d.ts +++ b/src/lib/es2015.iterable.d.ts @@ -88,7 +88,7 @@ interface ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(iterable: Iterable | ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; + from(iterable: Iterable | ArrayLike, /** @immediate */ mapfn: (v: T, k: number) => U, thisArg?: any): U[]; } interface ReadonlyArray { @@ -277,7 +277,7 @@ interface Int8ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; + from(arrayLike: Iterable, /** @immediate */ mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; } interface Uint8Array { @@ -305,7 +305,7 @@ interface Uint8ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; + from(arrayLike: Iterable, /** @immediate */ mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; } interface Uint8ClampedArray { @@ -335,7 +335,7 @@ interface Uint8ClampedArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; + from(arrayLike: Iterable, /** @immediate */ mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; } interface Int16Array { @@ -365,7 +365,7 @@ interface Int16ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; + from(arrayLike: Iterable, /** @immediate */ mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; } interface Uint16Array { @@ -393,7 +393,7 @@ interface Uint16ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; + from(arrayLike: Iterable, /** @immediate */ mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; } interface Int32Array { @@ -421,7 +421,7 @@ interface Int32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; + from(arrayLike: Iterable, /** @immediate */ mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; } interface Uint32Array { @@ -449,7 +449,7 @@ interface Uint32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; + from(arrayLike: Iterable, /** @immediate */ mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; } interface Float32Array { @@ -477,7 +477,7 @@ interface Float32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; + from(arrayLike: Iterable, /** @immediate */ mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; } interface Float64Array { @@ -505,5 +505,5 @@ interface Float64ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; + from(arrayLike: Iterable, /** @immediate */ mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; } diff --git a/src/lib/es2018.promise.d.ts b/src/lib/es2018.promise.d.ts index 57b91790615c2..070c4972f1141 100644 --- a/src/lib/es2018.promise.d.ts +++ b/src/lib/es2018.promise.d.ts @@ -8,5 +8,5 @@ interface Promise { * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). * @returns A Promise for the completion of the callback. */ - finally(/** @deferred */ onfinally?: (() => void) | undefined | null): Promise; + finally(onfinally?: (() => void) | undefined | null): Promise; } diff --git a/src/lib/es2019.array.d.ts b/src/lib/es2019.array.d.ts index c2da39b76435f..aaa8191f76428 100644 --- a/src/lib/es2019.array.d.ts +++ b/src/lib/es2019.array.d.ts @@ -16,7 +16,7 @@ interface ReadonlyArray { * thisArg is omitted, undefined is used as the this value. */ flatMap( - callback: (this: This, value: T, index: number, array: T[]) => U | ReadonlyArray, + /** @immediate */ callback: (this: This, value: T, index: number, array: T[]) => U | ReadonlyArray, thisArg?: This, ): U[]; @@ -44,7 +44,7 @@ interface Array { * thisArg is omitted, undefined is used as the this value. */ flatMap( - callback: (this: This, value: T, index: number, array: T[]) => U | ReadonlyArray, + /** @immediate */ callback: (this: This, value: T, index: number, array: T[]) => U | ReadonlyArray, thisArg?: This, ): U[]; diff --git a/src/lib/es2020.bigint.d.ts b/src/lib/es2020.bigint.d.ts index 95d2ff245897c..a78bbbb6ad707 100644 --- a/src/lib/es2020.bigint.d.ts +++ b/src/lib/es2020.bigint.d.ts @@ -163,7 +163,7 @@ interface BigInt64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean; + every(/** @immediate */ predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -182,7 +182,7 @@ interface BigInt64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: bigint, index: number, array: BigInt64Array) => any, thisArg?: any): BigInt64Array; + filter(/** @immediate */ predicate: (value: bigint, index: number, array: BigInt64Array) => any, thisArg?: any): BigInt64Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -193,7 +193,7 @@ interface BigInt64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): bigint | undefined; + find(/** @immediate */ predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): bigint | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -204,7 +204,7 @@ interface BigInt64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): number; + findIndex(/** @immediate */ predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -213,7 +213,7 @@ interface BigInt64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: bigint, index: number, array: BigInt64Array) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: bigint, index: number, array: BigInt64Array) => void, thisArg?: any): void; /** * Determines whether an array includes a certain element, returning true or false as appropriate. @@ -259,7 +259,7 @@ interface BigInt64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: bigint, index: number, array: BigInt64Array) => bigint, thisArg?: any): BigInt64Array; + map(/** @immediate */ callbackfn: (value: bigint, index: number, array: BigInt64Array) => bigint, thisArg?: any): BigInt64Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -271,7 +271,7 @@ interface BigInt64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint; + reduce(/** @immediate */ callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -283,7 +283,7 @@ interface BigInt64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -295,7 +295,7 @@ interface BigInt64Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint; + reduceRight(/** @immediate */ callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -307,7 +307,7 @@ interface BigInt64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U; + reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U; /** Reverses the elements in the array. */ reverse(): this; @@ -334,13 +334,13 @@ interface BigInt64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean; + some(/** @immediate */ predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean; /** * Sorts the array. * @param compareFn The function used to determine the order of the elements. If omitted, the elements are sorted in ascending order. */ - sort(compareFn?: (a: bigint, b: bigint) => number | bigint): this; + sort(/** @immediate */ compareFn?: (a: bigint, b: bigint) => number | bigint): this; /** * Gets a new BigInt64Array view of the ArrayBuffer store for this array, referencing the elements @@ -391,7 +391,7 @@ interface BigInt64ArrayConstructor { * @param thisArg Value of 'this' used to invoke the mapfn. */ from(arrayLike: ArrayLike): BigInt64Array; - from(arrayLike: ArrayLike, mapfn: (v: U, k: number) => bigint, thisArg?: any): BigInt64Array; + from(arrayLike: ArrayLike, /** @immediate */ mapfn: (v: U, k: number) => bigint, thisArg?: any): BigInt64Array; } declare var BigInt64Array: BigInt64ArrayConstructor; @@ -435,7 +435,7 @@ interface BigUint64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean; + every(/** @immediate */ predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -454,7 +454,7 @@ interface BigUint64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: bigint, index: number, array: BigUint64Array) => any, thisArg?: any): BigUint64Array; + filter(/** @immediate */ predicate: (value: bigint, index: number, array: BigUint64Array) => any, thisArg?: any): BigUint64Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -465,7 +465,7 @@ interface BigUint64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): bigint | undefined; + find(/** @immediate */ predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): bigint | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -476,7 +476,7 @@ interface BigUint64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): number; + findIndex(/** @immediate */ predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -485,7 +485,7 @@ interface BigUint64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: bigint, index: number, array: BigUint64Array) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: bigint, index: number, array: BigUint64Array) => void, thisArg?: any): void; /** * Determines whether an array includes a certain element, returning true or false as appropriate. @@ -531,7 +531,7 @@ interface BigUint64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: bigint, index: number, array: BigUint64Array) => bigint, thisArg?: any): BigUint64Array; + map(/** @immediate */ callbackfn: (value: bigint, index: number, array: BigUint64Array) => bigint, thisArg?: any): BigUint64Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -543,7 +543,7 @@ interface BigUint64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint; + reduce(/** @immediate */ callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -555,7 +555,7 @@ interface BigUint64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -567,7 +567,7 @@ interface BigUint64Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint; + reduceRight(/** @immediate */ callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -579,7 +579,7 @@ interface BigUint64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U; + reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U; /** Reverses the elements in the array. */ reverse(): this; @@ -606,13 +606,13 @@ interface BigUint64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean; + some(/** @immediate */ predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean; /** * Sorts the array. * @param compareFn The function used to determine the order of the elements. If omitted, the elements are sorted in ascending order. */ - sort(compareFn?: (a: bigint, b: bigint) => number | bigint): this; + sort(/** @immediate */ compareFn?: (a: bigint, b: bigint) => number | bigint): this; /** * Gets a new BigUint64Array view of the ArrayBuffer store for this array, referencing the elements @@ -663,7 +663,7 @@ interface BigUint64ArrayConstructor { * @param thisArg Value of 'this' used to invoke the mapfn. */ from(arrayLike: ArrayLike): BigUint64Array; - from(arrayLike: ArrayLike, mapfn: (v: U, k: number) => bigint, thisArg?: any): BigUint64Array; + from(arrayLike: ArrayLike, /** @immediate */ mapfn: (v: U, k: number) => bigint, thisArg?: any): BigUint64Array; } declare var BigUint64Array: BigUint64ArrayConstructor; diff --git a/src/lib/es2023.array.d.ts b/src/lib/es2023.array.d.ts index b0793a61a6c09..4f01c7634f308 100644 --- a/src/lib/es2023.array.d.ts +++ b/src/lib/es2023.array.d.ts @@ -8,8 +8,8 @@ interface Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findLast(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S | undefined; - findLast(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T | undefined; + findLast(/** @immediate */ predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S | undefined; + findLast(/** @immediate */ predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T | undefined; /** * Returns the index of the last element in the array where predicate is true, and -1 @@ -20,7 +20,7 @@ interface Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findLastIndex(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): number; + findLastIndex(/** @immediate */ predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): number; /** * Returns a copy of an array with its elements reversed. @@ -36,7 +36,7 @@ interface Array { * [11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22] * ``` */ - toSorted(compareFn?: (a: T, b: T) => number): T[]; + toSorted(/** @immediate */ compareFn?: (a: T, b: T) => number): T[]; /** * Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array. @@ -78,11 +78,11 @@ interface ReadonlyArray { * predicate. If it is not provided, undefined is used instead. */ findLast( - predicate: (value: T, index: number, array: readonly T[]) => value is S, + /** @immediate */ predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any, ): S | undefined; findLast( - predicate: (value: T, index: number, array: readonly T[]) => unknown, + /** @immediate */ predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any, ): T | undefined; @@ -96,7 +96,7 @@ interface ReadonlyArray { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: (value: T, index: number, array: readonly T[]) => unknown, + /** @immediate */ predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any, ): number; @@ -114,7 +114,7 @@ interface ReadonlyArray { * [11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22] * ``` */ - toSorted(compareFn?: (a: T, b: T) => number): T[]; + toSorted(/** @immediate */ compareFn?: (a: T, b: T) => number): T[]; /** * Copies an array and removes elements while, if necessary, inserting new elements in their place, returning the remaining elements. @@ -156,7 +156,7 @@ interface Int8Array { * predicate. If it is not provided, undefined is used instead. */ findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Int8Array, @@ -164,7 +164,7 @@ interface Int8Array { thisArg?: any, ): S | undefined; findLast( - predicate: (value: number, index: number, array: Int8Array) => unknown, + /** @immediate */ predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any, ): number | undefined; @@ -178,7 +178,7 @@ interface Int8Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: (value: number, index: number, array: Int8Array) => unknown, + /** @immediate */ predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any, ): number; @@ -197,7 +197,7 @@ interface Int8Array { * myNums.toSorted((a, b) => a - b) // Int8Array(4) [1, 2, 11, 22] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Int8Array; + toSorted(/** @immediate */ compareFn?: (a: number, b: number) => number): Int8Array; /** * Copies the array and inserts the given number at the provided index. @@ -220,7 +220,7 @@ interface Uint8Array { * predicate. If it is not provided, undefined is used instead. */ findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Uint8Array, @@ -228,7 +228,7 @@ interface Uint8Array { thisArg?: any, ): S | undefined; findLast( - predicate: (value: number, index: number, array: Uint8Array) => unknown, + /** @immediate */ predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any, ): number | undefined; @@ -242,7 +242,7 @@ interface Uint8Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: (value: number, index: number, array: Uint8Array) => unknown, + /** @immediate */ predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any, ): number; @@ -261,7 +261,7 @@ interface Uint8Array { * myNums.toSorted((a, b) => a - b) // Uint8Array(4) [1, 2, 11, 22] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Uint8Array; + toSorted(/** @immediate */ compareFn?: (a: number, b: number) => number): Uint8Array; /** * Copies the array and inserts the given number at the provided index. @@ -284,7 +284,7 @@ interface Uint8ClampedArray { * predicate. If it is not provided, undefined is used instead. */ findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Uint8ClampedArray, @@ -292,7 +292,7 @@ interface Uint8ClampedArray { thisArg?: any, ): S | undefined; findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Uint8ClampedArray, @@ -310,7 +310,7 @@ interface Uint8ClampedArray { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Uint8ClampedArray, @@ -333,7 +333,7 @@ interface Uint8ClampedArray { * myNums.toSorted((a, b) => a - b) // Uint8ClampedArray(4) [1, 2, 11, 22] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Uint8ClampedArray; + toSorted(/** @immediate */ compareFn?: (a: number, b: number) => number): Uint8ClampedArray; /** * Copies the array and inserts the given number at the provided index. @@ -356,7 +356,7 @@ interface Int16Array { * predicate. If it is not provided, undefined is used instead. */ findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Int16Array, @@ -364,7 +364,7 @@ interface Int16Array { thisArg?: any, ): S | undefined; findLast( - predicate: (value: number, index: number, array: Int16Array) => unknown, + /** @immediate */ predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any, ): number | undefined; @@ -378,7 +378,7 @@ interface Int16Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: (value: number, index: number, array: Int16Array) => unknown, + /** @immediate */ predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any, ): number; @@ -397,7 +397,7 @@ interface Int16Array { * myNums.toSorted((a, b) => a - b) // Int16Array(4) [-22, 1, 2, 11] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Int16Array; + toSorted(/** @immediate */ compareFn?: (a: number, b: number) => number): Int16Array; /** * Copies the array and inserts the given number at the provided index. @@ -420,7 +420,7 @@ interface Uint16Array { * predicate. If it is not provided, undefined is used instead. */ findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Uint16Array, @@ -428,7 +428,7 @@ interface Uint16Array { thisArg?: any, ): S | undefined; findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Uint16Array, @@ -446,7 +446,7 @@ interface Uint16Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Uint16Array, @@ -469,7 +469,7 @@ interface Uint16Array { * myNums.toSorted((a, b) => a - b) // Uint16Array(4) [1, 2, 11, 22] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Uint16Array; + toSorted(/** @immediate */ compareFn?: (a: number, b: number) => number): Uint16Array; /** * Copies the array and inserts the given number at the provided index. @@ -492,7 +492,7 @@ interface Int32Array { * predicate. If it is not provided, undefined is used instead. */ findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Int32Array, @@ -500,7 +500,7 @@ interface Int32Array { thisArg?: any, ): S | undefined; findLast( - predicate: (value: number, index: number, array: Int32Array) => unknown, + /** @immediate */ predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any, ): number | undefined; @@ -514,7 +514,7 @@ interface Int32Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: (value: number, index: number, array: Int32Array) => unknown, + /** @immediate */ predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any, ): number; @@ -533,7 +533,7 @@ interface Int32Array { * myNums.toSorted((a, b) => a - b) // Int32Array(4) [-22, 1, 2, 11] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Int32Array; + toSorted(/** @immediate */ compareFn?: (a: number, b: number) => number): Int32Array; /** * Copies the array and inserts the given number at the provided index. @@ -556,7 +556,7 @@ interface Uint32Array { * predicate. If it is not provided, undefined is used instead. */ findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Uint32Array, @@ -564,7 +564,7 @@ interface Uint32Array { thisArg?: any, ): S | undefined; findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Uint32Array, @@ -582,7 +582,7 @@ interface Uint32Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Uint32Array, @@ -605,7 +605,7 @@ interface Uint32Array { * myNums.toSorted((a, b) => a - b) // Uint32Array(4) [1, 2, 11, 22] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Uint32Array; + toSorted(/** @immediate */ compareFn?: (a: number, b: number) => number): Uint32Array; /** * Copies the array and inserts the given number at the provided index. @@ -628,7 +628,7 @@ interface Float32Array { * predicate. If it is not provided, undefined is used instead. */ findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Float32Array, @@ -636,7 +636,7 @@ interface Float32Array { thisArg?: any, ): S | undefined; findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Float32Array, @@ -654,7 +654,7 @@ interface Float32Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Float32Array, @@ -677,7 +677,7 @@ interface Float32Array { * myNums.toSorted((a, b) => a - b) // Float32Array(4) [-22.5, 1, 2, 11.5] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Float32Array; + toSorted(/** @immediate */ compareFn?: (a: number, b: number) => number): Float32Array; /** * Copies the array and inserts the given number at the provided index. @@ -700,7 +700,7 @@ interface Float64Array { * predicate. If it is not provided, undefined is used instead. */ findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Float64Array, @@ -708,7 +708,7 @@ interface Float64Array { thisArg?: any, ): S | undefined; findLast( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Float64Array, @@ -726,7 +726,7 @@ interface Float64Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: ( + /** @immediate */ predicate: ( value: number, index: number, array: Float64Array, @@ -749,7 +749,7 @@ interface Float64Array { * myNums.toSorted((a, b) => a - b) // Float64Array(4) [-22.5, 1, 2, 11.5] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Float64Array; + toSorted(/** @immediate */ compareFn?: (a: number, b: number) => number): Float64Array; /** * Copies the array and inserts the given number at the provided index. @@ -772,7 +772,7 @@ interface BigInt64Array { * predicate. If it is not provided, undefined is used instead. */ findLast( - predicate: ( + /** @immediate */ predicate: ( value: bigint, index: number, array: BigInt64Array, @@ -780,7 +780,7 @@ interface BigInt64Array { thisArg?: any, ): S | undefined; findLast( - predicate: ( + /** @immediate */ predicate: ( value: bigint, index: number, array: BigInt64Array, @@ -798,7 +798,7 @@ interface BigInt64Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: ( + /** @immediate */ predicate: ( value: bigint, index: number, array: BigInt64Array, @@ -821,7 +821,7 @@ interface BigInt64Array { * myNums.toSorted((a, b) => Number(a - b)) // BigInt64Array(4) [-22n, 1n, 2n, 11n] * ``` */ - toSorted(compareFn?: (a: bigint, b: bigint) => number): BigInt64Array; + toSorted(/** @immediate */ compareFn?: (a: bigint, b: bigint) => number): BigInt64Array; /** * Copies the array and inserts the given bigint at the provided index. @@ -844,7 +844,7 @@ interface BigUint64Array { * predicate. If it is not provided, undefined is used instead. */ findLast( - predicate: ( + /** @immediate */ predicate: ( value: bigint, index: number, array: BigUint64Array, @@ -852,7 +852,7 @@ interface BigUint64Array { thisArg?: any, ): S | undefined; findLast( - predicate: ( + /** @immediate */ predicate: ( value: bigint, index: number, array: BigUint64Array, @@ -870,7 +870,7 @@ interface BigUint64Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: ( + /** @immediate */ predicate: ( value: bigint, index: number, array: BigUint64Array, @@ -893,7 +893,7 @@ interface BigUint64Array { * myNums.toSorted((a, b) => Number(a - b)) // BigUint64Array(4) [1n, 2n, 11n, 22n] * ``` */ - toSorted(compareFn?: (a: bigint, b: bigint) => number): BigUint64Array; + toSorted(/** @immediate */ compareFn?: (a: bigint, b: bigint) => number): BigUint64Array; /** * Copies the array and inserts the given bigint at the provided index. diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts index 2fe625db3f9da..3251bb480d094 100644 --- a/src/lib/es5.d.ts +++ b/src/lib/es5.d.ts @@ -449,7 +449,7 @@ interface String { * @param searchValue A string to search for. * @param replacer A function that returns the replacement text. */ - replace(searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string; + replace(searchValue: string | RegExp, /** @immediate */ replacer: (substring: string, ...args: any[]) => string): string; /** * Finds the first substring match in a regular expression search. @@ -1141,14 +1141,14 @@ interface JSON { * @param reviver A function that transforms the results. This function is called for each member of the object. * If a member contains nested objects, the nested objects are transformed before the parent object is. */ - parse(text: string, reviver?: (this: any, key: string, value: any) => any): any; + parse(text: string, /** @immediate */ reviver?: (this: any, key: string, value: any) => any): any; /** * Converts a JavaScript value to a JavaScript Object Notation (JSON) string. * @param value A JavaScript value, usually an object or array, to be converted. * @param replacer A function that transforms the results. * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read. */ - stringify(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string; + stringify(value: any, /** @immediate */ replacer?: (this: any, key: string, value: any) => any, space?: string | number): string; /** * Converts a JavaScript value to a JavaScript Object Notation (JSON) string. * @param value A JavaScript value, usually an object or array, to be converted. @@ -1221,7 +1221,7 @@ interface ReadonlyArray { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): this is readonly S[]; + every(/** @immediate */ predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): this is readonly S[]; /** * Determines whether all the members of an array satisfy the specified test. * @param predicate A function that accepts up to three arguments. The every method calls @@ -1230,7 +1230,7 @@ interface ReadonlyArray { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean; + every(/** @immediate */ predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean; /** * Determines whether the specified callback function returns true for any element of an array. * @param predicate A function that accepts up to three arguments. The some method calls @@ -1239,57 +1239,57 @@ interface ReadonlyArray { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean; + some(/** @immediate */ predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean; /** * Performs the specified action for each element in an array. * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: T, index: number, array: readonly T[]) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: T, index: number, array: readonly T[]) => void, thisArg?: any): void; /** * Calls a defined callback function on each element of an array, and returns an array that contains the results. * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[]; + map(/** @immediate */ callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[]; /** * Returns the elements of an array that meet the condition specified in a callback function. * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S[]; + filter(/** @immediate */ predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S[]; /** * Returns the elements of an array that meet the condition specified in a callback function. * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T[]; + filter(/** @immediate */ predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T[]; /** * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array. * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. */ - reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T; - reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T; + reduce(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T; + reduce(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T; /** * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array. * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T; - reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T; + reduceRight(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T; + reduceRight(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T; /** * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U; + reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U; readonly [n: number]: T; } @@ -1371,7 +1371,7 @@ interface Array { * [11,2,22,1].sort((a, b) => a - b) * ``` */ - sort(compareFn?: (a: T, b: T) => number): this; + sort(/** @immediate */ compareFn?: (a: T, b: T) => number): this; /** * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements. * @param start The zero-based location in the array from which to start removing elements. @@ -1412,7 +1412,7 @@ interface Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[]; + every(/** @immediate */ predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[]; /** * Determines whether all the members of an array satisfy the specified test. * @param predicate A function that accepts up to three arguments. The every method calls @@ -1421,7 +1421,7 @@ interface Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; + every(/** @immediate */ predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; /** * Determines whether the specified callback function returns true for any element of an array. * @param predicate A function that accepts up to three arguments. The some method calls @@ -1430,57 +1430,57 @@ interface Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; + some(/** @immediate */ predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; /** * Performs the specified action for each element in an array. * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; /** * Calls a defined callback function on each element of an array, and returns an array that contains the results. * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; + map(/** @immediate */ callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; /** * Returns the elements of an array that meet the condition specified in a callback function. * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; + filter(/** @immediate */ predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; /** * Returns the elements of an array that meet the condition specified in a callback function. * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array. * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; + filter(/** @immediate */ predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; /** * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array. * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. */ - reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; - reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; + reduce(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; + reduce(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; /** * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array. * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; - reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; + reduceRight(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; + reduceRight(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; /** * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; + reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; [n: number]: T; } @@ -1516,7 +1516,7 @@ interface PromiseLike { * @param onrejected The callback to execute when the Promise is rejected. * @returns A Promise for the completion of which ever callback is executed. */ - then(/** @deferred */ onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, /** @deferred */ onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): PromiseLike; + then(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): PromiseLike; } /** @@ -1529,14 +1529,14 @@ interface Promise { * @param onrejected The callback to execute when the Promise is rejected. * @returns A Promise for the completion of which ever callback is executed. */ - then(/** @deferred */ onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, /** @deferred */ onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; + then(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; /** * Attaches a callback for only the rejection of the Promise. * @param onrejected The callback to execute when the Promise is rejected. * @returns A Promise for the completion of the callback. */ - catch(/** @deferred */ onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; + catch(onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; } /** @@ -1896,7 +1896,7 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): boolean; + every(/** @immediate */ predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -1915,7 +1915,7 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Int8Array) => any, thisArg?: any): Int8Array; + filter(/** @immediate */ predicate: (value: number, index: number, array: Int8Array) => any, thisArg?: any): Int8Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -1926,7 +1926,7 @@ interface Int8Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Int8Array) => boolean, thisArg?: any): number | undefined; + find(/** @immediate */ predicate: (value: number, index: number, obj: Int8Array) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -1937,7 +1937,7 @@ interface Int8Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Int8Array) => boolean, thisArg?: any): number; + findIndex(/** @immediate */ predicate: (value: number, index: number, obj: Int8Array) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -1946,7 +1946,7 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Int8Array) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: number, index: number, array: Int8Array) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -1984,7 +1984,7 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Int8Array) => number, thisArg?: any): Int8Array; + map(/** @immediate */ callbackfn: (value: number, index: number, array: Int8Array) => number, thisArg?: any): Int8Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -1996,8 +1996,8 @@ interface Int8Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue: number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2009,7 +2009,7 @@ interface Int8Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int8Array) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int8Array) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2021,8 +2021,8 @@ interface Int8Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue: number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2034,7 +2034,7 @@ interface Int8Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int8Array) => U, initialValue: U): U; + reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int8Array) => U, initialValue: U): U; /** * Reverses the elements in an Array. @@ -2063,7 +2063,7 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): boolean; + some(/** @immediate */ predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -2074,7 +2074,7 @@ interface Int8Array { * [11,2,22,1].sort((a, b) => a - b) * ``` */ - sort(compareFn?: (a: number, b: number) => number): this; + sort(/** @immediate */ comparefn?: (a: number, b: number) => number): this; /** * Gets a new Int8Array view of the ArrayBuffer store for this array, referencing the elements @@ -2128,7 +2128,7 @@ interface Int8ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Int8Array; + from(arrayLike: ArrayLike, /** @immediate */ mapfn: (v: T, k: number) => number, thisArg?: any): Int8Array; } declare var Int8Array: Int8ArrayConstructor; @@ -2176,7 +2176,7 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): boolean; + every(/** @immediate */ predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -2195,7 +2195,7 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Uint8Array) => any, thisArg?: any): Uint8Array; + filter(/** @immediate */ predicate: (value: number, index: number, array: Uint8Array) => any, thisArg?: any): Uint8Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -2206,7 +2206,7 @@ interface Uint8Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Uint8Array) => boolean, thisArg?: any): number | undefined; + find(/** @immediate */ predicate: (value: number, index: number, obj: Uint8Array) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -2217,7 +2217,7 @@ interface Uint8Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Uint8Array) => boolean, thisArg?: any): number; + findIndex(/** @immediate */ predicate: (value: number, index: number, obj: Uint8Array) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -2226,7 +2226,7 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Uint8Array) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: number, index: number, array: Uint8Array) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -2264,7 +2264,7 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Uint8Array) => number, thisArg?: any): Uint8Array; + map(/** @immediate */ callbackfn: (value: number, index: number, array: Uint8Array) => number, thisArg?: any): Uint8Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2276,8 +2276,8 @@ interface Uint8Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue: number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2289,7 +2289,7 @@ interface Uint8Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2301,8 +2301,8 @@ interface Uint8Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue: number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2314,7 +2314,7 @@ interface Uint8Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array) => U, initialValue: U): U; + reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array) => U, initialValue: U): U; /** * Reverses the elements in an Array. @@ -2343,7 +2343,7 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): boolean; + some(/** @immediate */ predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -2354,7 +2354,7 @@ interface Uint8Array { * [11,2,22,1].sort((a, b) => a - b) * ``` */ - sort(compareFn?: (a: number, b: number) => number): this; + sort(/** @immediate */ comparefn?: (a: number, b: number) => number): this; /** * Gets a new Uint8Array view of the ArrayBuffer store for this array, referencing the elements @@ -2409,7 +2409,7 @@ interface Uint8ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array; + from(arrayLike: ArrayLike, /** @immediate */ mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array; } declare var Uint8Array: Uint8ArrayConstructor; @@ -2457,7 +2457,7 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): boolean; + every(/** @immediate */ predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -2476,7 +2476,7 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Uint8ClampedArray) => any, thisArg?: any): Uint8ClampedArray; + filter(/** @immediate */ predicate: (value: number, index: number, array: Uint8ClampedArray) => any, thisArg?: any): Uint8ClampedArray; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -2487,7 +2487,7 @@ interface Uint8ClampedArray { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Uint8ClampedArray) => boolean, thisArg?: any): number | undefined; + find(/** @immediate */ predicate: (value: number, index: number, obj: Uint8ClampedArray) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -2498,7 +2498,7 @@ interface Uint8ClampedArray { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Uint8ClampedArray) => boolean, thisArg?: any): number; + findIndex(/** @immediate */ predicate: (value: number, index: number, obj: Uint8ClampedArray) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -2507,7 +2507,7 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Uint8ClampedArray) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: number, index: number, array: Uint8ClampedArray) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -2545,7 +2545,7 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Uint8ClampedArray) => number, thisArg?: any): Uint8ClampedArray; + map(/** @immediate */ callbackfn: (value: number, index: number, array: Uint8ClampedArray) => number, thisArg?: any): Uint8ClampedArray; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2557,8 +2557,8 @@ interface Uint8ClampedArray { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue: number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2570,7 +2570,7 @@ interface Uint8ClampedArray { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2582,8 +2582,8 @@ interface Uint8ClampedArray { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue: number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2595,7 +2595,7 @@ interface Uint8ClampedArray { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => U, initialValue: U): U; + reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => U, initialValue: U): U; /** * Reverses the elements in an Array. @@ -2624,7 +2624,7 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): boolean; + some(/** @immediate */ predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -2635,7 +2635,7 @@ interface Uint8ClampedArray { * [11,2,22,1].sort((a, b) => a - b) * ``` */ - sort(compareFn?: (a: number, b: number) => number): this; + sort(/** @immediate */ comparefn?: (a: number, b: number) => number): this; /** * Gets a new Uint8ClampedArray view of the ArrayBuffer store for this array, referencing the elements @@ -2690,7 +2690,7 @@ interface Uint8ClampedArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8ClampedArray; + from(arrayLike: ArrayLike, /** @immediate */ mapfn: (v: T, k: number) => number, thisArg?: any): Uint8ClampedArray; } declare var Uint8ClampedArray: Uint8ClampedArrayConstructor; @@ -2738,7 +2738,7 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): boolean; + every(/** @immediate */ predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -2757,7 +2757,7 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Int16Array) => any, thisArg?: any): Int16Array; + filter(/** @immediate */ predicate: (value: number, index: number, array: Int16Array) => any, thisArg?: any): Int16Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -2768,7 +2768,7 @@ interface Int16Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Int16Array) => boolean, thisArg?: any): number | undefined; + find(/** @immediate */ predicate: (value: number, index: number, obj: Int16Array) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -2779,7 +2779,7 @@ interface Int16Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Int16Array) => boolean, thisArg?: any): number; + findIndex(/** @immediate */ predicate: (value: number, index: number, obj: Int16Array) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -2788,7 +2788,7 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Int16Array) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: number, index: number, array: Int16Array) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. * @param searchElement The value to locate in the array. @@ -2825,7 +2825,7 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Int16Array) => number, thisArg?: any): Int16Array; + map(/** @immediate */ callbackfn: (value: number, index: number, array: Int16Array) => number, thisArg?: any): Int16Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2837,8 +2837,8 @@ interface Int16Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue: number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2850,7 +2850,7 @@ interface Int16Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int16Array) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int16Array) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2862,8 +2862,8 @@ interface Int16Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue: number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2875,7 +2875,7 @@ interface Int16Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int16Array) => U, initialValue: U): U; + reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int16Array) => U, initialValue: U): U; /** * Reverses the elements in an Array. @@ -2904,7 +2904,7 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): boolean; + some(/** @immediate */ predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -2915,7 +2915,7 @@ interface Int16Array { * [11,2,22,1].sort((a, b) => a - b) * ``` */ - sort(compareFn?: (a: number, b: number) => number): this; + sort(/** @immediate */ comparefn?: (a: number, b: number) => number): this; /** * Gets a new Int16Array view of the ArrayBuffer store for this array, referencing the elements @@ -2970,7 +2970,7 @@ interface Int16ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Int16Array; + from(arrayLike: ArrayLike, /** @immediate */ mapfn: (v: T, k: number) => number, thisArg?: any): Int16Array; } declare var Int16Array: Int16ArrayConstructor; @@ -3018,7 +3018,7 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): boolean; + every(/** @immediate */ predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -3037,7 +3037,7 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Uint16Array) => any, thisArg?: any): Uint16Array; + filter(/** @immediate */ predicate: (value: number, index: number, array: Uint16Array) => any, thisArg?: any): Uint16Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -3048,7 +3048,7 @@ interface Uint16Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Uint16Array) => boolean, thisArg?: any): number | undefined; + find(/** @immediate */ predicate: (value: number, index: number, obj: Uint16Array) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -3059,7 +3059,7 @@ interface Uint16Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Uint16Array) => boolean, thisArg?: any): number; + findIndex(/** @immediate */ predicate: (value: number, index: number, obj: Uint16Array) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -3068,7 +3068,7 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Uint16Array) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: number, index: number, array: Uint16Array) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -3106,7 +3106,7 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Uint16Array) => number, thisArg?: any): Uint16Array; + map(/** @immediate */ callbackfn: (value: number, index: number, array: Uint16Array) => number, thisArg?: any): Uint16Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3118,8 +3118,8 @@ interface Uint16Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue: number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3131,7 +3131,7 @@ interface Uint16Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint16Array) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint16Array) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3143,8 +3143,8 @@ interface Uint16Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue: number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3156,7 +3156,7 @@ interface Uint16Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint16Array) => U, initialValue: U): U; + reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint16Array) => U, initialValue: U): U; /** * Reverses the elements in an Array. @@ -3185,7 +3185,7 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): boolean; + some(/** @immediate */ predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -3196,7 +3196,7 @@ interface Uint16Array { * [11,2,22,1].sort((a, b) => a - b) * ``` */ - sort(compareFn?: (a: number, b: number) => number): this; + sort(/** @immediate */ comparefn?: (a: number, b: number) => number): this; /** * Gets a new Uint16Array view of the ArrayBuffer store for this array, referencing the elements @@ -3251,7 +3251,7 @@ interface Uint16ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Uint16Array; + from(arrayLike: ArrayLike, /** @immediate */ mapfn: (v: T, k: number) => number, thisArg?: any): Uint16Array; } declare var Uint16Array: Uint16ArrayConstructor; /** @@ -3298,7 +3298,7 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): boolean; + every(/** @immediate */ predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -3317,7 +3317,7 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Int32Array) => any, thisArg?: any): Int32Array; + filter(/** @immediate */ predicate: (value: number, index: number, array: Int32Array) => any, thisArg?: any): Int32Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -3328,7 +3328,7 @@ interface Int32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Int32Array) => boolean, thisArg?: any): number | undefined; + find(/** @immediate */ predicate: (value: number, index: number, obj: Int32Array) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -3339,7 +3339,7 @@ interface Int32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Int32Array) => boolean, thisArg?: any): number; + findIndex(/** @immediate */ predicate: (value: number, index: number, obj: Int32Array) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -3348,7 +3348,7 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Int32Array) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: number, index: number, array: Int32Array) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -3386,7 +3386,7 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Int32Array) => number, thisArg?: any): Int32Array; + map(/** @immediate */ callbackfn: (value: number, index: number, array: Int32Array) => number, thisArg?: any): Int32Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3398,8 +3398,8 @@ interface Int32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue: number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3411,7 +3411,7 @@ interface Int32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int32Array) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int32Array) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3423,8 +3423,8 @@ interface Int32Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue: number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3436,7 +3436,7 @@ interface Int32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int32Array) => U, initialValue: U): U; + reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int32Array) => U, initialValue: U): U; /** * Reverses the elements in an Array. @@ -3465,7 +3465,7 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): boolean; + some(/** @immediate */ predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -3476,7 +3476,7 @@ interface Int32Array { * [11,2,22,1].sort((a, b) => a - b) * ``` */ - sort(compareFn?: (a: number, b: number) => number): this; + sort(/** @immediate */ comparefn?: (a: number, b: number) => number): this; /** * Gets a new Int32Array view of the ArrayBuffer store for this array, referencing the elements @@ -3531,7 +3531,7 @@ interface Int32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Int32Array; + from(arrayLike: ArrayLike, /** @immediate */ mapfn: (v: T, k: number) => number, thisArg?: any): Int32Array; } declare var Int32Array: Int32ArrayConstructor; @@ -3579,7 +3579,7 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): boolean; + every(/** @immediate */ predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -3598,7 +3598,7 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Uint32Array) => any, thisArg?: any): Uint32Array; + filter(/** @immediate */ predicate: (value: number, index: number, array: Uint32Array) => any, thisArg?: any): Uint32Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -3609,7 +3609,7 @@ interface Uint32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Uint32Array) => boolean, thisArg?: any): number | undefined; + find(/** @immediate */ predicate: (value: number, index: number, obj: Uint32Array) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -3620,7 +3620,7 @@ interface Uint32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Uint32Array) => boolean, thisArg?: any): number; + findIndex(/** @immediate */ predicate: (value: number, index: number, obj: Uint32Array) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -3629,7 +3629,7 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Uint32Array) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: number, index: number, array: Uint32Array) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. * @param searchElement The value to locate in the array. @@ -3666,7 +3666,7 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Uint32Array) => number, thisArg?: any): Uint32Array; + map(/** @immediate */ callbackfn: (value: number, index: number, array: Uint32Array) => number, thisArg?: any): Uint32Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3678,8 +3678,8 @@ interface Uint32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue: number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3691,7 +3691,7 @@ interface Uint32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint32Array) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint32Array) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3703,8 +3703,8 @@ interface Uint32Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue: number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3716,7 +3716,7 @@ interface Uint32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint32Array) => U, initialValue: U): U; + reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint32Array) => U, initialValue: U): U; /** * Reverses the elements in an Array. @@ -3745,7 +3745,7 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): boolean; + some(/** @immediate */ predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -3756,7 +3756,7 @@ interface Uint32Array { * [11,2,22,1].sort((a, b) => a - b) * ``` */ - sort(compareFn?: (a: number, b: number) => number): this; + sort(/** @immediate */ comparefn?: (a: number, b: number) => number): this; /** * Gets a new Uint32Array view of the ArrayBuffer store for this array, referencing the elements @@ -3811,7 +3811,7 @@ interface Uint32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Uint32Array; + from(arrayLike: ArrayLike, /** @immediate */ mapfn: (v: T, k: number) => number, thisArg?: any): Uint32Array; } declare var Uint32Array: Uint32ArrayConstructor; @@ -3859,7 +3859,7 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): boolean; + every(/** @immediate */ predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -3878,7 +3878,7 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Float32Array) => any, thisArg?: any): Float32Array; + filter(/** @immediate */ predicate: (value: number, index: number, array: Float32Array) => any, thisArg?: any): Float32Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -3889,7 +3889,7 @@ interface Float32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Float32Array) => boolean, thisArg?: any): number | undefined; + find(/** @immediate */ predicate: (value: number, index: number, obj: Float32Array) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -3900,7 +3900,7 @@ interface Float32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Float32Array) => boolean, thisArg?: any): number; + findIndex(/** @immediate */ predicate: (value: number, index: number, obj: Float32Array) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -3909,7 +3909,7 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Float32Array) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: number, index: number, array: Float32Array) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -3947,7 +3947,7 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Float32Array) => number, thisArg?: any): Float32Array; + map(/** @immediate */ callbackfn: (value: number, index: number, array: Float32Array) => number, thisArg?: any): Float32Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3959,8 +3959,8 @@ interface Float32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue: number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3972,7 +3972,7 @@ interface Float32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float32Array) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float32Array) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3984,8 +3984,8 @@ interface Float32Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue: number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3997,7 +3997,7 @@ interface Float32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float32Array) => U, initialValue: U): U; + reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float32Array) => U, initialValue: U): U; /** * Reverses the elements in an Array. @@ -4026,7 +4026,7 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): boolean; + some(/** @immediate */ predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -4037,7 +4037,7 @@ interface Float32Array { * [11,2,22,1].sort((a, b) => a - b) * ``` */ - sort(compareFn?: (a: number, b: number) => number): this; + sort(/** @immediate */ comparefn?: (a: number, b: number) => number): this; /** * Gets a new Float32Array view of the ArrayBuffer store for this array, referencing the elements @@ -4092,7 +4092,7 @@ interface Float32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Float32Array; + from(arrayLike: ArrayLike, /** @immediate */ mapfn: (v: T, k: number) => number, thisArg?: any): Float32Array; } declare var Float32Array: Float32ArrayConstructor; @@ -4140,7 +4140,7 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): boolean; + every(/** @immediate */ predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -4159,7 +4159,7 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Float64Array) => any, thisArg?: any): Float64Array; + filter(/** @immediate */ predicate: (value: number, index: number, array: Float64Array) => any, thisArg?: any): Float64Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -4170,7 +4170,7 @@ interface Float64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any): number | undefined; + find(/** @immediate */ predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -4181,7 +4181,7 @@ interface Float64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any): number; + findIndex(/** @immediate */ predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -4190,7 +4190,7 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any): void; + forEach(/** @immediate */ callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -4228,7 +4228,7 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any): Float64Array; + map(/** @immediate */ callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any): Float64Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -4240,8 +4240,8 @@ interface Float64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number; + reduce(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -4253,7 +4253,7 @@ interface Float64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -4265,8 +4265,8 @@ interface Float64Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number; + reduceRight(/** @immediate */ callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -4278,7 +4278,7 @@ interface Float64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U; + reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U; /** * Reverses the elements in an Array. @@ -4307,7 +4307,7 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): boolean; + some(/** @immediate */ predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -4318,7 +4318,7 @@ interface Float64Array { * [11,2,22,1].sort((a, b) => a - b) * ``` */ - sort(compareFn?: (a: number, b: number) => number): this; + sort(/** @immediate */ comparefn?: (a: number, b: number) => number): this; /** * Gets a new Float64Array view of the ArrayBuffer store for this array, referencing the elements @@ -4373,7 +4373,7 @@ interface Float64ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Float64Array; + from(arrayLike: ArrayLike, /** @immediate */ mapfn: (v: T, k: number) => number, thisArg?: any): Float64Array; } declare var Float64Array: Float64ArrayConstructor; diff --git a/src/lib/esnext.array.d.ts b/src/lib/esnext.array.d.ts index 6842e5d0c401a..1afbf34fd0b96 100644 --- a/src/lib/esnext.array.d.ts +++ b/src/lib/esnext.array.d.ts @@ -13,5 +13,5 @@ interface ArrayConstructor { * Each return value is awaited before being added to result array. * @param thisArg Value of 'this' used when executing mapfn. */ - fromAsync(iterableOrArrayLike: AsyncIterable | Iterable | ArrayLike, mapFn: (value: Awaited) => U, thisArg?: any): Promise[]>; + fromAsync(iterableOrArrayLike: AsyncIterable | Iterable | ArrayLike, /** @immediate */ mapFn: (value: Awaited) => U, thisArg?: any): Promise[]>; } diff --git a/src/lib/esnext.collection.d.ts b/src/lib/esnext.collection.d.ts index 504ed6782d4bb..207a1bbdf03b9 100644 --- a/src/lib/esnext.collection.d.ts +++ b/src/lib/esnext.collection.d.ts @@ -6,7 +6,7 @@ interface MapConstructor { */ groupBy( items: Iterable, - keySelector: (item: T, index: number) => K, + /** @immediate */ keySelector: (item: T, index: number) => K, ): Map; } diff --git a/src/lib/esnext.iterator.d.ts b/src/lib/esnext.iterator.d.ts index fe929f59c2206..cb97030941410 100644 --- a/src/lib/esnext.iterator.d.ts +++ b/src/lib/esnext.iterator.d.ts @@ -29,19 +29,19 @@ declare global { * Creates an iterator whose values are the result of applying the callback to the values from this iterator. * @param callbackfn A function that accepts up to two arguments to be used to transform values from the underlying iterator. */ - map(callbackfn: (value: T, index: number) => U): IteratorObject; + map(/** @immediate */ callbackfn: (value: T, index: number) => U): IteratorObject; /** * Creates an iterator whose values are those from this iterator for which the provided predicate returns true. * @param predicate A function that accepts up to two arguments to be used to test values from the underlying iterator. */ - filter(predicate: (value: T, index: number) => value is S): IteratorObject; + filter(/** @immediate */ predicate: (value: T, index: number) => value is S): IteratorObject; /** * Creates an iterator whose values are those from this iterator for which the provided predicate returns true. * @param predicate A function that accepts up to two arguments to be used to test values from the underlying iterator. */ - filter(predicate: (value: T, index: number) => unknown): IteratorObject; + filter(/** @immediate */ predicate: (value: T, index: number) => unknown): IteratorObject; /** * Creates an iterator whose values are the values from this iterator, stopping once the provided limit is reached. @@ -59,22 +59,22 @@ declare global { * Creates an iterator whose values are the result of applying the callback to the values from this iterator and then flattening the resulting iterators or iterables. * @param callback A function that accepts up to two arguments to be used to transform values from the underlying iterator into new iterators or iterables to be flattened into the result. */ - flatMap(callback: (value: T, index: number) => Iterator | Iterable): IteratorObject; + flatMap(/** @immediate */ callback: (value: T, index: number) => Iterator | Iterable): IteratorObject; /** * Calls the specified callback function for all the elements in this iterator. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. * @param callbackfn A function that accepts up to three arguments. The reduce method calls the callbackfn function one time for each element in the iterator. * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of a value from the iterator. */ - reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T): T; - reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T, initialValue: T): T; + reduce(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T): T; + reduce(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T, initialValue: T): T; /** * Calls the specified callback function for all the elements in this iterator. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. * @param callbackfn A function that accepts up to three arguments. The reduce method calls the callbackfn function one time for each element in the iterator. * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of a value from the iterator. */ - reduce(callbackfn: (previousValue: U, currentValue: T, currentIndex: number) => U, initialValue: U): U; + reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: T, currentIndex: number) => U, initialValue: U): U; /** * Creates a new array from the values yielded by this iterator. @@ -85,7 +85,7 @@ declare global { * Performs the specified action for each element in the iterator. * @param callbackfn A function that accepts up to two arguments. forEach calls the callbackfn function one time for each element in the iterator. */ - forEach(callbackfn: (value: T, index: number) => void): void; + forEach(/** @immediate */ callbackfn: (value: T, index: number) => void): void; /** * Determines whether the specified callback function returns true for any element of this iterator. @@ -93,7 +93,7 @@ declare global { * the predicate function for each element in this iterator until the predicate returns a value * true, or until the end of the iterator. */ - some(predicate: (value: T, index: number) => unknown): boolean; + some(/** @immediate */ predicate: (value: T, index: number) => unknown): boolean; /** * Determines whether all the members of this iterator satisfy the specified test. @@ -101,7 +101,7 @@ declare global { * the predicate function for each element in this iterator until the predicate returns * false, or until the end of this iterator. */ - every(predicate: (value: T, index: number) => unknown): boolean; + every(/** @immediate */ predicate: (value: T, index: number) => unknown): boolean; /** * Returns the value of the first element in this iterator where predicate is true, and undefined @@ -110,8 +110,8 @@ declare global { * order, until it finds one where predicate returns true. If such an element is found, find * immediately returns that element value. Otherwise, find returns undefined. */ - find(predicate: (value: T, index: number) => value is S): S | undefined; - find(predicate: (value: T, index: number) => unknown): T | undefined; + find(/** @immediate */ predicate: (value: T, index: number) => value is S): S | undefined; + find(/** @immediate */ predicate: (value: T, index: number) => unknown): T | undefined; readonly [Symbol.toStringTag]: string; } diff --git a/src/lib/esnext.object.d.ts b/src/lib/esnext.object.d.ts index 0486ac078139c..28986ea8f2eb3 100644 --- a/src/lib/esnext.object.d.ts +++ b/src/lib/esnext.object.d.ts @@ -6,6 +6,6 @@ interface ObjectConstructor { */ groupBy( items: Iterable, - keySelector: (item: T, index: number) => K, + /** @immediate */ keySelector: (item: T, index: number) => K, ): Partial>; } From b60fbc053d3dcc3fb7081c584bb20f4dc93e2fe5 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 8 Aug 2024 10:26:03 -0700 Subject: [PATCH 26/30] Update tests --- tests/cases/compiler/deferredCallbacks.ts | 238 --------------------- tests/cases/compiler/immediateCallbacks.ts | 238 +++++++++++++++++++++ 2 files changed, 238 insertions(+), 238 deletions(-) delete mode 100644 tests/cases/compiler/deferredCallbacks.ts create mode 100644 tests/cases/compiler/immediateCallbacks.ts diff --git a/tests/cases/compiler/deferredCallbacks.ts b/tests/cases/compiler/deferredCallbacks.ts deleted file mode 100644 index 33f324704c2e9..0000000000000 --- a/tests/cases/compiler/deferredCallbacks.ts +++ /dev/null @@ -1,238 +0,0 @@ -// @strict: true -// @declaration: true -// @target: esnext - -declare function immediate(cb: () => void): void; -declare function deferred1(deferred cb: () => void): void; -declare function deferred2(/** @deferred */ cb: () => void): void; -declare function deferred3(/** @deferred */ deferred cb: () => void): void; - -function f01() { - let x: string | number = "OK"; - immediate(() => { - x = 42; - }); - x; // string | number -} - -function f02() { - let x: string | number = "OK"; - deferred1(() => { - x = 42; - }); - x; // string -} - -function f03() { - let x: string | number = "OK"; - deferred2(() => { - x = 42; - }); - x; // string -} - -function f04() { - let x: string | number = "OK"; - deferred3(() => { - x = 42; - }); - x; // string -} - -// Parameter is considered deferred if one or more overloads defer that parameter - -declare function overloaded(cb: (x: T) => T): void; -declare function overloaded(cb: (x: T, y: T) => T): void; -declare function overloaded(deferred cb: (...args: any) => any): void; - -function f05() { - let x: string | number = "OK"; - overloaded(() => { - x = 42; - }); - x.length; -} - -// deferred is permitted on a rest parameter - -declare function invokeImmediate(...args: ((...args: any) => any)[]): void; -declare function invokeDeferred(deferred ...args: ((...args: any) => any)[]): void; - -function f06() { - let a = []; - a.push("abc"); - a; // string[] - invokeImmediate( - () => { - a; // string[] - a.push(42); - a; // (string | number)[] - }, - () => { - a; // string[] - a.push(true); - a; // (string | boolean)[] - } - ); - a; // (string | number | boolean)[] -} - -function f07() { - let a = []; - a.push("abc"); - a; // string[] - invokeDeferred( - () => { - a; // string[] - a.push(42); - a; // (string | number)[] - }, - () => { - a; // string[] - a.push(true); - a; // (string | boolean)[] - } - ); - a; // string[] -} - -// deferred modifier must precede public/private/protected/readonly - -class CC { - constructor(deferred public readonly x: () => void) {} -} - -// deferred requires parameter to have type that permits functions - -declare function f10(deferred f: () => void): void; -declare function f11(deferred f: Function): void; -declare function f12(deferred f: any): void; -declare function f13(deferred f: object): void; -declare function f14(deferred f: {}): void; -declare function f15(deferred f: unknown): void; -declare function f16(deferred f: T): void; -declare function f17 any>(deferred f: T): void; -declare function f18 void)>(deferred f: T): void; - -declare function f20(deferred ...funcs: Function[]): void; -declare function f21 any)[]>(deferred ...funcs: T): void; -declare function f22 void))[]>(deferred ...funcs: T): void; -declare function f23 void)[]>(deferred ...funcs: T): void; -declare function f24 void)[]>(deferred ...funcs: T | string[]): void; - -declare function f30(deferred f: { foo(): void }): void; -declare function f31(deferred f: number): void; -declare function f32(deferred ...funcs: number[]): void; - -type T10 = (deferred f: () => void) => void; -type T11 = (deferred f: { (): void }) => void; -type T12 = (deferred f: Function) => void; -type T13 = (deferred f: any) => void; - -type T20 = (deferred f: { foo(): void }) => void; -type T21 = (deferred f: number) => void; -type T22 = (deferred ...funcs: number[]) => void; -type T23 = { deferred x: () => void }; - -// deferred modifier is not captured in argument list tuples - -declare function doStuff(deferred f: () => void): void; - -declare function recreate(f: (...args: A) => R): (...args: A) => R; -declare function recreateDeferred1(f: (deferred ...args: A) => R): (...args: A) => R; -declare function recreateDeferred2(f: (...args: A) => R): (deferred ...args: A) => R; - -function ff1() { - let x: string | number; - x = 123; - doStuff(() => { - x = "hi"; - }); - x; // number -} - -function ff2() { - let y: string | number; - y = 123; - recreate(doStuff)(() => { - y = "hi"; - }); - y; // string | number -} - -function ff3() { - let z: string | number; - z = 123; - recreateDeferred1(doStuff)(() => { - z = "hi"; - }); - z; // string | number -} - -function ff4() { - let z: string | number; - z = 123; - recreateDeferred2(doStuff)(() => { - z = "hi"; - }); - z; // number -} - -// https://github.com/microsoft/TypeScript/issues/11498 - -declare function mystery(cb: () => void): void; - -function fx1() { - let x: string | number = "OK"; - x; // string - mystery(() => { - x = 10; - }); - x; // string | number - if (x === 10) {} -} - -// https://github.com/microsoft/TypeScript/issues/15380 - -class Foo { - public bar: string = ""; -} - -function fx2() { - let foo: Foo | null = null; - [1].forEach((item) => { - foo = new Foo(); - }); - if (foo) { - foo.bar; - } -} - -// https://github.com/microsoft/TypeScript/issues/57880 - -const call = (f: () => void) => f(); - -const fx3 = () => { - let a: undefined | number = undefined; - call(() => { a = 1; }); - if (a !== undefined) { - a.toString(); - } -}; - -// https://github.com/microsoft/TypeScript/issues/58291 - -async function execute(onError: (_err: Error | undefined) => void) { - onError(new Error("a")); -} - -async function run() { - let result: boolean = true; - await execute(() => { - result = false; - }); - if (result === false) { - console.log("error"); - } - return result; -} diff --git a/tests/cases/compiler/immediateCallbacks.ts b/tests/cases/compiler/immediateCallbacks.ts new file mode 100644 index 0000000000000..f8a1129e6fc2b --- /dev/null +++ b/tests/cases/compiler/immediateCallbacks.ts @@ -0,0 +1,238 @@ +// @strict: true +// @noemit: true +// @target: esnext + +declare function deferred(cb: () => void): void; +declare function immediate1(immediate cb: () => void): void; +declare function immediate2(/** @immediate */ cb: () => void): void; +declare function immediate3(/** @immediate */ immediate cb: () => void): void; + +function f01() { + let x: string | number = "OK"; + deferred(() => { + x = 42; + }); + x; // string +} + +function f02() { + let x: string | number = "OK"; + immediate1(() => { + x = 42; + }); + x; // string | number +} + +function f03() { + let x: string | number = "OK"; + immediate2(() => { + x = 42; + }); + x; // string | number +} + +function f04() { + let x: string | number = "OK"; + immediate3(() => { + x = 42; + }); + x; // string | number +} + +// Parameter is considered immediate if one or more overloads include the modifier in that parameter position + +declare function overloaded(cb: (x: T) => T): void; +declare function overloaded(cb: (x: T, y: T) => T): void; +declare function overloaded(immediate cb: (...args: any) => any): void; + +function f05() { + let x: string | number = "OK"; + overloaded(() => { + x = 42; + }); + x; // string | number +} + +// immediate is permitted on a rest parameter + +declare function invokeDeferred(...args: ((...args: any) => any)[]): void; +declare function invokeImmediate(immediate ...args: ((...args: any) => any)[]): void; + +function f06() { + let a = []; + a.push("abc"); + a; // string[] + invokeImmediate( + () => { + a; // string[] + a.push(42); + a; // (string | number)[] + }, + () => { + a; // string[] + a.push(true); + a; // (string | boolean)[] + } + ); + a; // (string | number | boolean)[] +} + +function f07() { + let a = []; + a.push("abc"); + a; // string[] + invokeDeferred( + () => { + a; // string[] + a.push(42); + a; // (string | number)[] + }, + () => { + a; // string[] + a.push(true); + a; // (string | boolean)[] + } + ); + a; // string[] +} + +// immediate modifier must precede public/private/protected/readonly + +class CC { + constructor(immediate public readonly x: () => void) {} +} + +// immediate requires parameter to have type that permits functions + +declare function f10(immediate f: () => void): void; +declare function f11(immediate f: Function): void; +declare function f12(immediate f: any): void; +declare function f13(immediate f: object): void; +declare function f14(immediate f: {}): void; +declare function f15(immediate f: unknown): void; +declare function f16(immediate f: T): void; +declare function f17 any>(immediate f: T): void; +declare function f18 void)>(immediate f: T): void; + +declare function f20(immediate ...funcs: Function[]): void; +declare function f21 any)[]>(immediate ...funcs: T): void; +declare function f22 void))[]>(immediate ...funcs: T): void; +declare function f23 void)[]>(immediate ...funcs: T): void; +declare function f24 void)[]>(immediate ...funcs: T | string[]): void; + +declare function f30(immediate f: { foo(): void }): void; +declare function f31(immediate f: number): void; +declare function f32(immediate ...funcs: number[]): void; + +type T10 = (immediate f: () => void) => void; +type T11 = (immediate f: { (): void }) => void; +type T12 = (immediate f: Function) => void; +type T13 = (immediate f: any) => void; + +type T20 = (immediate f: { foo(): void }) => void; +type T21 = (immediate f: number) => void; +type T22 = (immediate ...funcs: number[]) => void; +type T23 = { immediate x: () => void }; + +// immediate modifier is not captured in argument list tuples + +declare function doStuff(immediate f: () => void): void; + +declare function recreate(f: (...args: A) => R): (...args: A) => R; +declare function recreateImmediate1(f: (immediate ...args: A) => R): (...args: A) => R; +declare function recreateImmediate2(f: (...args: A) => R): (immediate ...args: A) => R; + +function ff1() { + let x: string | number; + x = 123; + doStuff(() => { + x = "hi"; + }); + x; // string | number +} + +function ff2() { + let y: string | number; + y = 123; + recreate(doStuff)(() => { + y = "hi"; + }); + y; // number +} + +function ff3() { + let z: string | number; + z = 123; + recreateImmediate1(doStuff)(() => { + z = "hi"; + }); + z; // number +} + +function ff4() { + let z: string | number; + z = 123; + recreateImmediate2(doStuff)(() => { + z = "hi"; + }); + z; // string | number +} + +// https://github.com/microsoft/TypeScript/issues/11498 + +declare function mystery(immediate cb: () => void): void; + +function fx1() { + let x: string | number = "OK"; + x; // string + mystery(() => { + x = 10; + }); + x; // string | number + if (x === 10) {} +} + +// https://github.com/microsoft/TypeScript/issues/15380 + +class Foo { + public bar: string = ""; +} + +function fx2() { + let foo: Foo | null = null; + [1].forEach((item) => { + foo = new Foo(); + }); + if (foo) { + foo.bar; + } +} + +// https://github.com/microsoft/TypeScript/issues/57880 + +const call = (immediate f: () => void) => f(); + +const fx3 = () => { + let a: undefined | number = undefined; + call(() => { a = 1; }); + if (a !== undefined) { + a.toString(); + } +}; + +// https://github.com/microsoft/TypeScript/issues/58291 + +async function execute(immediate onError: (_err: Error | undefined) => void) { + onError(new Error("a")); +} + +async function run() { + let result: boolean = true; + await execute(() => { + result = false; + }); + if (result === false) { + console.log("error"); + } + return result; +} From 7f7ccf63b99ce9930a9bf4ea9b93f680901bf11d Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 8 Aug 2024 10:26:26 -0700 Subject: [PATCH 27/30] Accept new baselines --- tests/baselines/reference/api/typescript.d.ts | 32 +- ...oToTypeDefinition_arrayType.baseline.jsonc | 56 +- ...oTypeDefinition_promiseType.baseline.jsonc | 8 +- .../reference/immediateCallbacks.errors.txt | 259 +++++ .../reference/immediateCallbacks.symbols | 625 ++++++++++ .../reference/immediateCallbacks.types | 1031 +++++++++++++++++ tests/baselines/reference/parserharness.types | 4 +- .../baselines/reference/parserindenter.types | 4 +- 8 files changed, 1967 insertions(+), 52 deletions(-) create mode 100644 tests/baselines/reference/immediateCallbacks.errors.txt create mode 100644 tests/baselines/reference/immediateCallbacks.symbols create mode 100644 tests/baselines/reference/immediateCallbacks.types diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index d22c2087a3a1f..6cf611df37e0a 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -3763,8 +3763,8 @@ declare namespace ts { BooleanKeyword = 136, ConstructorKeyword = 137, DeclareKeyword = 138, - DeferredKeyword = 139, - GetKeyword = 140, + GetKeyword = 139, + ImmediateKeyword = 140, InferKeyword = 141, IntrinsicKeyword = 142, IsKeyword = 143, @@ -3961,7 +3961,7 @@ declare namespace ts { JSDocImplementsTag = 330, JSDocAuthorTag = 331, JSDocDeprecatedTag = 332, - JSDocDeferredTag = 333, + JSDocImmediateTag = 333, JSDocClassTag = 334, JSDocPublicTag = 335, JSDocPrivateTag = 336, @@ -4106,7 +4106,6 @@ declare namespace ts { | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword - | SyntaxKind.DeferredKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword @@ -4121,6 +4120,7 @@ declare namespace ts { | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword + | SyntaxKind.ImmediateKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword @@ -4170,7 +4170,7 @@ declare namespace ts { | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword; - type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AccessorKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeferredKeyword | SyntaxKind.ExportKeyword | SyntaxKind.InKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.StaticKeyword; + type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AccessorKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ImmediateKeyword | SyntaxKind.InKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.StaticKeyword; type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword; type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PseudoLiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind; type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken; @@ -4227,9 +4227,9 @@ declare namespace ts { In = 8192, Out = 16384, Decorator = 32768, - Deferred = 65536, + Immediate = 65536, Deprecated = 131072, - JSDocDeferred = 262144, + JSDocImmediate = 262144, HasComputedJSDocModifiers = 268435456, HasComputedFlags = 536870912, AccessibilityModifier = 7, @@ -4387,8 +4387,8 @@ declare namespace ts { type ConstKeyword = ModifierToken; type DeclareKeyword = ModifierToken; type DefaultKeyword = ModifierToken; - type DeferredKeyword = ModifierToken; type ExportKeyword = ModifierToken; + type ImmediateKeyword = ModifierToken; type InKeyword = ModifierToken; type PrivateKeyword = ModifierToken; type ProtectedKeyword = ModifierToken; @@ -4397,7 +4397,7 @@ declare namespace ts { type OutKeyword = ModifierToken; type OverrideKeyword = ModifierToken; type StaticKeyword = ModifierToken; - type Modifier = AbstractKeyword | AccessorKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | DeferredKeyword | ExportKeyword | InKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OutKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword; + type Modifier = AbstractKeyword | AccessorKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | ImmediateKeyword | InKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OutKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword; type ModifierLike = Modifier | Decorator; type AccessibilityModifier = PublicKeyword | PrivateKeyword | ProtectedKeyword; type ParameterPropertyModifier = AccessibilityModifier | ReadonlyKeyword; @@ -5727,8 +5727,8 @@ declare namespace ts { interface JSDocDeprecatedTag extends JSDocTag { kind: SyntaxKind.JSDocDeprecatedTag; } - interface JSDocDeferredTag extends JSDocTag { - kind: SyntaxKind.JSDocDeferredTag; + interface JSDocImmediateTag extends JSDocTag { + kind: SyntaxKind.JSDocImmediateTag; } interface JSDocClassTag extends JSDocTag { readonly kind: SyntaxKind.JSDocClassTag; @@ -7745,8 +7745,8 @@ declare namespace ts { updateJSDocUnknownTag(node: JSDocUnknownTag, tagName: Identifier, comment: string | NodeArray | undefined): JSDocUnknownTag; createJSDocDeprecatedTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeprecatedTag; updateJSDocDeprecatedTag(node: JSDocDeprecatedTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeprecatedTag; - createJSDocDeferredTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeferredTag; - updateJSDocDeferredTag(node: JSDocDeferredTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeferredTag; + createJSDocImmediateTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocImmediateTag; + updateJSDocImmediateTag(node: JSDocImmediateTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocImmediateTag; createJSDocOverrideTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocOverrideTag; updateJSDocOverrideTag(node: JSDocOverrideTag, tagName: Identifier | undefined, comment?: string | NodeArray): JSDocOverrideTag; createJSDocThrowsTag(tagName: Identifier, typeExpression: JSDocTypeExpression | undefined, comment?: string | NodeArray): JSDocThrowsTag; @@ -8600,8 +8600,8 @@ declare namespace ts { function getJSDocOverrideTagNoCache(node: Node): JSDocOverrideTag | undefined; /** Gets the JSDoc deprecated tag for the node if present */ function getJSDocDeprecatedTag(node: Node): JSDocDeprecatedTag | undefined; - /** Gets the JSDoc deferred tag for the node if present */ - function getJSDocDeferredTag(node: Node): JSDocDeferredTag | undefined; + /** Gets the JSDoc immediate tag for the node if present */ + function getJSDocImmediateTag(node: Node): JSDocImmediateTag | undefined; /** Gets the JSDoc enum tag for the node if present */ function getJSDocEnumTag(node: Node): JSDocEnumTag | undefined; /** Gets the JSDoc this tag for the node if present */ @@ -9046,7 +9046,7 @@ declare namespace ts { function isJSDocOverrideTag(node: Node): node is JSDocOverrideTag; function isJSDocOverloadTag(node: Node): node is JSDocOverloadTag; function isJSDocDeprecatedTag(node: Node): node is JSDocDeprecatedTag; - function isJSDocDeferredTag(node: Node): node is JSDocDeferredTag; + function isJSDocImmediateTag(node: Node): node is JSDocImmediateTag; function isJSDocSeeTag(node: Node): node is JSDocSeeTag; function isJSDocEnumTag(node: Node): node is JSDocEnumTag; function isJSDocParameterTag(node: Node): node is JSDocParameterTag; diff --git a/tests/baselines/reference/goToTypeDefinition_arrayType.baseline.jsonc b/tests/baselines/reference/goToTypeDefinition_arrayType.baseline.jsonc index 1dc5b63951e85..aea831a5590d4 100644 --- a/tests/baselines/reference/goToTypeDefinition_arrayType.baseline.jsonc +++ b/tests/baselines/reference/goToTypeDefinition_arrayType.baseline.jsonc @@ -83,7 +83,7 @@ // * [11,2,22,1].sort((a, b) => a - b) // * ``` // */ -// sort(compareFn?: (a: T, b: T) => number): this; +// sort(/** @immediate */ compareFn?: (a: T, b: T) => number): this; // /** // * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements. // * @param start The zero-based location in the array from which to start removing elements. @@ -124,7 +124,7 @@ // * @param thisArg An object to which the this keyword can refer in the predicate function. // * If thisArg is omitted, undefined is used as the this value. // */ -// every(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[]; +// every(/** @immediate */ predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[]; // /** // * Determines whether all the members of an array satisfy the specified test. // * @param predicate A function that accepts up to three arguments. The every method calls @@ -133,7 +133,7 @@ // * @param thisArg An object to which the this keyword can refer in the predicate function. // * If thisArg is omitted, undefined is used as the this value. // */ -// every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; +// every(/** @immediate */ predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; // /** // * Determines whether the specified callback function returns true for any element of an array. // * @param predicate A function that accepts up to three arguments. The some method calls @@ -142,57 +142,57 @@ // * @param thisArg An object to which the this keyword can refer in the predicate function. // * If thisArg is omitted, undefined is used as the this value. // */ -// some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; +// some(/** @immediate */ predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; // /** // * Performs the specified action for each element in an array. // * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. // * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. // */ -// forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; +// forEach(/** @immediate */ callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; // /** // * Calls a defined callback function on each element of an array, and returns an array that contains the results. // * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. // * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. // */ -// map(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; +// map(/** @immediate */ callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; // /** // * Returns the elements of an array that meet the condition specified in a callback function. // * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array. // * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value. // */ -// filter(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; +// filter(/** @immediate */ predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; // /** // * Returns the elements of an array that meet the condition specified in a callback function. // * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array. // * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value. // */ -// filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; +// filter(/** @immediate */ predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; // /** // * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. // * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array. // * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. // */ -// reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; -// reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; +// reduce(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; +// reduce(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; // /** // * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. // * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array. // * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. // */ -// reduce(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; +// reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; // /** // * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. // * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. // * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. // */ -// reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; -// reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; +// reduceRight(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; +// reduceRight(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; // /** // * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. // * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. // * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. // */ -// reduceRight(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; +// reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; // // [n: number]: T; // }|> @@ -336,7 +336,7 @@ // * [11,2,22,1].sort((a, b) => a - b) // * ``` // */ -// sort(compareFn?: (a: T, b: T) => number): this; +// sort(/** @immediate */ compareFn?: (a: T, b: T) => number): this; // /** // * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements. // * @param start The zero-based location in the array from which to start removing elements. @@ -377,7 +377,7 @@ // * @param thisArg An object to which the this keyword can refer in the predicate function. // * If thisArg is omitted, undefined is used as the this value. // */ -// every(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[]; +// every(/** @immediate */ predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[]; // /** // * Determines whether all the members of an array satisfy the specified test. // * @param predicate A function that accepts up to three arguments. The every method calls @@ -386,7 +386,7 @@ // * @param thisArg An object to which the this keyword can refer in the predicate function. // * If thisArg is omitted, undefined is used as the this value. // */ -// every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; +// every(/** @immediate */ predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; // /** // * Determines whether the specified callback function returns true for any element of an array. // * @param predicate A function that accepts up to three arguments. The some method calls @@ -395,57 +395,57 @@ // * @param thisArg An object to which the this keyword can refer in the predicate function. // * If thisArg is omitted, undefined is used as the this value. // */ -// some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; +// some(/** @immediate */ predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean; // /** // * Performs the specified action for each element in an array. // * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. // * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. // */ -// forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; +// forEach(/** @immediate */ callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; // /** // * Calls a defined callback function on each element of an array, and returns an array that contains the results. // * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. // * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. // */ -// map(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; +// map(/** @immediate */ callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; // /** // * Returns the elements of an array that meet the condition specified in a callback function. // * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array. // * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value. // */ -// filter(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; +// filter(/** @immediate */ predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[]; // /** // * Returns the elements of an array that meet the condition specified in a callback function. // * @param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array. // * @param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value. // */ -// filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; +// filter(/** @immediate */ predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[]; // /** // * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. // * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array. // * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. // */ -// reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; -// reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; +// reduce(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; +// reduce(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; // /** // * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. // * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array. // * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. // */ -// reduce(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; +// reduce(/** @immediate */ callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; // /** // * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. // * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. // * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. // */ -// reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; -// reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; +// reduceRight(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T; +// reduceRight(/** @immediate */ callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T; // /** // * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. // * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. // * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. // */ -// reduceRight(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; +// reduceRight(/** @immediate */ callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; // // [n: number]: T; // }|> diff --git a/tests/baselines/reference/goToTypeDefinition_promiseType.baseline.jsonc b/tests/baselines/reference/goToTypeDefinition_promiseType.baseline.jsonc index f39b30067fce2..f84caf2e46250 100644 --- a/tests/baselines/reference/goToTypeDefinition_promiseType.baseline.jsonc +++ b/tests/baselines/reference/goToTypeDefinition_promiseType.baseline.jsonc @@ -19,14 +19,14 @@ // * @param onrejected The callback to execute when the Promise is rejected. // * @returns A Promise for the completion of which ever callback is executed. // */ -// then(/** @deferred */ onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, /** @deferred */ onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; +// then(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; // // /** // * Attaches a callback for only the rejection of the Promise. // * @param onrejected The callback to execute when the Promise is rejected. // * @returns A Promise for the completion of the callback. // */ -// catch(/** @deferred */ onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; +// catch(onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; // }|> // // /** @@ -80,14 +80,14 @@ // * @param onrejected The callback to execute when the Promise is rejected. // * @returns A Promise for the completion of which ever callback is executed. // */ -// then(/** @deferred */ onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, /** @deferred */ onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; +// then(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise; // // /** // * Attaches a callback for only the rejection of the Promise. // * @param onrejected The callback to execute when the Promise is rejected. // * @returns A Promise for the completion of the callback. // */ -// catch(/** @deferred */ onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; +// catch(onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise; // }|> // // /** diff --git a/tests/baselines/reference/immediateCallbacks.errors.txt b/tests/baselines/reference/immediateCallbacks.errors.txt new file mode 100644 index 0000000000000..2d2f723308315 --- /dev/null +++ b/tests/baselines/reference/immediateCallbacks.errors.txt @@ -0,0 +1,259 @@ +immediateCallbacks.ts(119,22): error TS2874: An 'immediate' parameter must have a type that permits functions. +immediateCallbacks.ts(120,22): error TS2874: An 'immediate' parameter must have a type that permits functions. +immediateCallbacks.ts(121,22): error TS2874: An 'immediate' parameter must have a type that permits functions. +immediateCallbacks.ts(128,13): error TS2874: An 'immediate' parameter must have a type that permits functions. +immediateCallbacks.ts(129,13): error TS2874: An 'immediate' parameter must have a type that permits functions. +immediateCallbacks.ts(130,13): error TS2874: An 'immediate' parameter must have a type that permits functions. +immediateCallbacks.ts(131,14): error TS1070: 'immediate' modifier cannot appear on a type member. + + +==== immediateCallbacks.ts (7 errors) ==== + declare function deferred(cb: () => void): void; + declare function immediate1(immediate cb: () => void): void; + declare function immediate2(/** @immediate */ cb: () => void): void; + declare function immediate3(/** @immediate */ immediate cb: () => void): void; + + function f01() { + let x: string | number = "OK"; + deferred(() => { + x = 42; + }); + x; // string + } + + function f02() { + let x: string | number = "OK"; + immediate1(() => { + x = 42; + }); + x; // string | number + } + + function f03() { + let x: string | number = "OK"; + immediate2(() => { + x = 42; + }); + x; // string | number + } + + function f04() { + let x: string | number = "OK"; + immediate3(() => { + x = 42; + }); + x; // string | number + } + + // Parameter is considered immediate if one or more overloads include the modifier in that parameter position + + declare function overloaded(cb: (x: T) => T): void; + declare function overloaded(cb: (x: T, y: T) => T): void; + declare function overloaded(immediate cb: (...args: any) => any): void; + + function f05() { + let x: string | number = "OK"; + overloaded(() => { + x = 42; + }); + x; // string | number + } + + // immediate is permitted on a rest parameter + + declare function invokeDeferred(...args: ((...args: any) => any)[]): void; + declare function invokeImmediate(immediate ...args: ((...args: any) => any)[]): void; + + function f06() { + let a = []; + a.push("abc"); + a; // string[] + invokeImmediate( + () => { + a; // string[] + a.push(42); + a; // (string | number)[] + }, + () => { + a; // string[] + a.push(true); + a; // (string | boolean)[] + } + ); + a; // (string | number | boolean)[] + } + + function f07() { + let a = []; + a.push("abc"); + a; // string[] + invokeDeferred( + () => { + a; // string[] + a.push(42); + a; // (string | number)[] + }, + () => { + a; // string[] + a.push(true); + a; // (string | boolean)[] + } + ); + a; // string[] + } + + // immediate modifier must precede public/private/protected/readonly + + class CC { + constructor(immediate public readonly x: () => void) {} + } + + // immediate requires parameter to have type that permits functions + + declare function f10(immediate f: () => void): void; + declare function f11(immediate f: Function): void; + declare function f12(immediate f: any): void; + declare function f13(immediate f: object): void; + declare function f14(immediate f: {}): void; + declare function f15(immediate f: unknown): void; + declare function f16(immediate f: T): void; + declare function f17 any>(immediate f: T): void; + declare function f18 void)>(immediate f: T): void; + + declare function f20(immediate ...funcs: Function[]): void; + declare function f21 any)[]>(immediate ...funcs: T): void; + declare function f22 void))[]>(immediate ...funcs: T): void; + declare function f23 void)[]>(immediate ...funcs: T): void; + declare function f24 void)[]>(immediate ...funcs: T | string[]): void; + + declare function f30(immediate f: { foo(): void }): void; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2874: An 'immediate' parameter must have a type that permits functions. + declare function f31(immediate f: number): void; + ~~~~~~~~~~~~~~~~~~~ +!!! error TS2874: An 'immediate' parameter must have a type that permits functions. + declare function f32(immediate ...funcs: number[]): void; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2874: An 'immediate' parameter must have a type that permits functions. + + type T10 = (immediate f: () => void) => void; + type T11 = (immediate f: { (): void }) => void; + type T12 = (immediate f: Function) => void; + type T13 = (immediate f: any) => void; + + type T20 = (immediate f: { foo(): void }) => void; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2874: An 'immediate' parameter must have a type that permits functions. + type T21 = (immediate f: number) => void; + ~~~~~~~~~~~~~~~~~~~ +!!! error TS2874: An 'immediate' parameter must have a type that permits functions. + type T22 = (immediate ...funcs: number[]) => void; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2874: An 'immediate' parameter must have a type that permits functions. + type T23 = { immediate x: () => void }; + ~~~~~~~~~ +!!! error TS1070: 'immediate' modifier cannot appear on a type member. + + // immediate modifier is not captured in argument list tuples + + declare function doStuff(immediate f: () => void): void; + + declare function recreate(f: (...args: A) => R): (...args: A) => R; + declare function recreateImmediate1(f: (immediate ...args: A) => R): (...args: A) => R; + declare function recreateImmediate2(f: (...args: A) => R): (immediate ...args: A) => R; + + function ff1() { + let x: string | number; + x = 123; + doStuff(() => { + x = "hi"; + }); + x; // string | number + } + + function ff2() { + let y: string | number; + y = 123; + recreate(doStuff)(() => { + y = "hi"; + }); + y; // number + } + + function ff3() { + let z: string | number; + z = 123; + recreateImmediate1(doStuff)(() => { + z = "hi"; + }); + z; // number + } + + function ff4() { + let z: string | number; + z = 123; + recreateImmediate2(doStuff)(() => { + z = "hi"; + }); + z; // string | number + } + + // https://github.com/microsoft/TypeScript/issues/11498 + + declare function mystery(immediate cb: () => void): void; + + function fx1() { + let x: string | number = "OK"; + x; // string + mystery(() => { + x = 10; + }); + x; // string | number + if (x === 10) {} + } + + // https://github.com/microsoft/TypeScript/issues/15380 + + class Foo { + public bar: string = ""; + } + + function fx2() { + let foo: Foo | null = null; + [1].forEach((item) => { + foo = new Foo(); + }); + if (foo) { + foo.bar; + } + } + + // https://github.com/microsoft/TypeScript/issues/57880 + + const call = (immediate f: () => void) => f(); + + const fx3 = () => { + let a: undefined | number = undefined; + call(() => { a = 1; }); + if (a !== undefined) { + a.toString(); + } + }; + + // https://github.com/microsoft/TypeScript/issues/58291 + + async function execute(immediate onError: (_err: Error | undefined) => void) { + onError(new Error("a")); + } + + async function run() { + let result: boolean = true; + await execute(() => { + result = false; + }); + if (result === false) { + console.log("error"); + } + return result; + } + \ No newline at end of file diff --git a/tests/baselines/reference/immediateCallbacks.symbols b/tests/baselines/reference/immediateCallbacks.symbols new file mode 100644 index 0000000000000..6c80081e718a4 --- /dev/null +++ b/tests/baselines/reference/immediateCallbacks.symbols @@ -0,0 +1,625 @@ +//// [tests/cases/compiler/immediateCallbacks.ts] //// + +=== immediateCallbacks.ts === +declare function deferred(cb: () => void): void; +>deferred : Symbol(deferred, Decl(immediateCallbacks.ts, 0, 0)) +>cb : Symbol(cb, Decl(immediateCallbacks.ts, 0, 26)) + +declare function immediate1(immediate cb: () => void): void; +>immediate1 : Symbol(immediate1, Decl(immediateCallbacks.ts, 0, 48)) +>cb : Symbol(cb, Decl(immediateCallbacks.ts, 1, 28)) + +declare function immediate2(/** @immediate */ cb: () => void): void; +>immediate2 : Symbol(immediate2, Decl(immediateCallbacks.ts, 1, 60)) +>cb : Symbol(cb, Decl(immediateCallbacks.ts, 2, 28)) + +declare function immediate3(/** @immediate */ immediate cb: () => void): void; +>immediate3 : Symbol(immediate3, Decl(immediateCallbacks.ts, 2, 68)) +>cb : Symbol(cb, Decl(immediateCallbacks.ts, 3, 28)) + +function f01() { +>f01 : Symbol(f01, Decl(immediateCallbacks.ts, 3, 78)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(immediateCallbacks.ts, 6, 7)) + + deferred(() => { +>deferred : Symbol(deferred, Decl(immediateCallbacks.ts, 0, 0)) + + x = 42; +>x : Symbol(x, Decl(immediateCallbacks.ts, 6, 7)) + + }); + x; // string +>x : Symbol(x, Decl(immediateCallbacks.ts, 6, 7)) +} + +function f02() { +>f02 : Symbol(f02, Decl(immediateCallbacks.ts, 11, 1)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(immediateCallbacks.ts, 14, 7)) + + immediate1(() => { +>immediate1 : Symbol(immediate1, Decl(immediateCallbacks.ts, 0, 48)) + + x = 42; +>x : Symbol(x, Decl(immediateCallbacks.ts, 14, 7)) + + }); + x; // string | number +>x : Symbol(x, Decl(immediateCallbacks.ts, 14, 7)) +} + +function f03() { +>f03 : Symbol(f03, Decl(immediateCallbacks.ts, 19, 1)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(immediateCallbacks.ts, 22, 7)) + + immediate2(() => { +>immediate2 : Symbol(immediate2, Decl(immediateCallbacks.ts, 1, 60)) + + x = 42; +>x : Symbol(x, Decl(immediateCallbacks.ts, 22, 7)) + + }); + x; // string | number +>x : Symbol(x, Decl(immediateCallbacks.ts, 22, 7)) +} + +function f04() { +>f04 : Symbol(f04, Decl(immediateCallbacks.ts, 27, 1)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(immediateCallbacks.ts, 30, 7)) + + immediate3(() => { +>immediate3 : Symbol(immediate3, Decl(immediateCallbacks.ts, 2, 68)) + + x = 42; +>x : Symbol(x, Decl(immediateCallbacks.ts, 30, 7)) + + }); + x; // string | number +>x : Symbol(x, Decl(immediateCallbacks.ts, 30, 7)) +} + +// Parameter is considered immediate if one or more overloads include the modifier in that parameter position + +declare function overloaded(cb: (x: T) => T): void; +>overloaded : Symbol(overloaded, Decl(immediateCallbacks.ts, 35, 1), Decl(immediateCallbacks.ts, 39, 54), Decl(immediateCallbacks.ts, 40, 60)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 39, 28)) +>cb : Symbol(cb, Decl(immediateCallbacks.ts, 39, 31)) +>x : Symbol(x, Decl(immediateCallbacks.ts, 39, 36)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 39, 28)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 39, 28)) + +declare function overloaded(cb: (x: T, y: T) => T): void; +>overloaded : Symbol(overloaded, Decl(immediateCallbacks.ts, 35, 1), Decl(immediateCallbacks.ts, 39, 54), Decl(immediateCallbacks.ts, 40, 60)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 40, 28)) +>cb : Symbol(cb, Decl(immediateCallbacks.ts, 40, 31)) +>x : Symbol(x, Decl(immediateCallbacks.ts, 40, 36)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 40, 28)) +>y : Symbol(y, Decl(immediateCallbacks.ts, 40, 41)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 40, 28)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 40, 28)) + +declare function overloaded(immediate cb: (...args: any) => any): void; +>overloaded : Symbol(overloaded, Decl(immediateCallbacks.ts, 35, 1), Decl(immediateCallbacks.ts, 39, 54), Decl(immediateCallbacks.ts, 40, 60)) +>cb : Symbol(cb, Decl(immediateCallbacks.ts, 41, 28)) +>args : Symbol(args, Decl(immediateCallbacks.ts, 41, 43)) + +function f05() { +>f05 : Symbol(f05, Decl(immediateCallbacks.ts, 41, 71)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(immediateCallbacks.ts, 44, 7)) + + overloaded(() => { +>overloaded : Symbol(overloaded, Decl(immediateCallbacks.ts, 35, 1), Decl(immediateCallbacks.ts, 39, 54), Decl(immediateCallbacks.ts, 40, 60)) + + x = 42; +>x : Symbol(x, Decl(immediateCallbacks.ts, 44, 7)) + + }); + x; // string | number +>x : Symbol(x, Decl(immediateCallbacks.ts, 44, 7)) +} + +// immediate is permitted on a rest parameter + +declare function invokeDeferred(...args: ((...args: any) => any)[]): void; +>invokeDeferred : Symbol(invokeDeferred, Decl(immediateCallbacks.ts, 49, 1)) +>args : Symbol(args, Decl(immediateCallbacks.ts, 53, 32)) +>args : Symbol(args, Decl(immediateCallbacks.ts, 53, 43)) + +declare function invokeImmediate(immediate ...args: ((...args: any) => any)[]): void; +>invokeImmediate : Symbol(invokeImmediate, Decl(immediateCallbacks.ts, 53, 74)) +>args : Symbol(args, Decl(immediateCallbacks.ts, 54, 33)) +>args : Symbol(args, Decl(immediateCallbacks.ts, 54, 54)) + +function f06() { +>f06 : Symbol(f06, Decl(immediateCallbacks.ts, 54, 85)) + + let a = []; +>a : Symbol(a, Decl(immediateCallbacks.ts, 57, 7)) + + a.push("abc"); +>a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(immediateCallbacks.ts, 57, 7)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) + + a; // string[] +>a : Symbol(a, Decl(immediateCallbacks.ts, 57, 7)) + + invokeImmediate( +>invokeImmediate : Symbol(invokeImmediate, Decl(immediateCallbacks.ts, 53, 74)) + + () => { + a; // string[] +>a : Symbol(a, Decl(immediateCallbacks.ts, 57, 7)) + + a.push(42); +>a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(immediateCallbacks.ts, 57, 7)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) + + a; // (string | number)[] +>a : Symbol(a, Decl(immediateCallbacks.ts, 57, 7)) + + }, + () => { + a; // string[] +>a : Symbol(a, Decl(immediateCallbacks.ts, 57, 7)) + + a.push(true); +>a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(immediateCallbacks.ts, 57, 7)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) + + a; // (string | boolean)[] +>a : Symbol(a, Decl(immediateCallbacks.ts, 57, 7)) + } + ); + a; // (string | number | boolean)[] +>a : Symbol(a, Decl(immediateCallbacks.ts, 57, 7)) +} + +function f07() { +>f07 : Symbol(f07, Decl(immediateCallbacks.ts, 73, 1)) + + let a = []; +>a : Symbol(a, Decl(immediateCallbacks.ts, 76, 7)) + + a.push("abc"); +>a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(immediateCallbacks.ts, 76, 7)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) + + a; // string[] +>a : Symbol(a, Decl(immediateCallbacks.ts, 76, 7)) + + invokeDeferred( +>invokeDeferred : Symbol(invokeDeferred, Decl(immediateCallbacks.ts, 49, 1)) + + () => { + a; // string[] +>a : Symbol(a, Decl(immediateCallbacks.ts, 76, 7)) + + a.push(42); +>a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(immediateCallbacks.ts, 76, 7)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) + + a; // (string | number)[] +>a : Symbol(a, Decl(immediateCallbacks.ts, 76, 7)) + + }, + () => { + a; // string[] +>a : Symbol(a, Decl(immediateCallbacks.ts, 76, 7)) + + a.push(true); +>a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(immediateCallbacks.ts, 76, 7)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) + + a; // (string | boolean)[] +>a : Symbol(a, Decl(immediateCallbacks.ts, 76, 7)) + } + ); + a; // string[] +>a : Symbol(a, Decl(immediateCallbacks.ts, 76, 7)) +} + +// immediate modifier must precede public/private/protected/readonly + +class CC { +>CC : Symbol(CC, Decl(immediateCallbacks.ts, 92, 1)) + + constructor(immediate public readonly x: () => void) {} +>x : Symbol(CC.x, Decl(immediateCallbacks.ts, 97, 16)) +} + +// immediate requires parameter to have type that permits functions + +declare function f10(immediate f: () => void): void; +>f10 : Symbol(f10, Decl(immediateCallbacks.ts, 98, 1)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 102, 21)) + +declare function f11(immediate f: Function): void; +>f11 : Symbol(f11, Decl(immediateCallbacks.ts, 102, 52)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 103, 21)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) + +declare function f12(immediate f: any): void; +>f12 : Symbol(f12, Decl(immediateCallbacks.ts, 103, 50)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 104, 21)) + +declare function f13(immediate f: object): void; +>f13 : Symbol(f13, Decl(immediateCallbacks.ts, 104, 45)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 105, 21)) + +declare function f14(immediate f: {}): void; +>f14 : Symbol(f14, Decl(immediateCallbacks.ts, 105, 48)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 106, 21)) + +declare function f15(immediate f: unknown): void; +>f15 : Symbol(f15, Decl(immediateCallbacks.ts, 106, 44)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 107, 21)) + +declare function f16(immediate f: T): void; +>f16 : Symbol(f16, Decl(immediateCallbacks.ts, 107, 49)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 108, 21)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 108, 41)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 108, 21)) + +declare function f17 any>(immediate f: T): void; +>f17 : Symbol(f17, Decl(immediateCallbacks.ts, 108, 63)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 109, 21)) +>args : Symbol(args, Decl(immediateCallbacks.ts, 109, 32)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 109, 54)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 109, 21)) + +declare function f18 void)>(immediate f: T): void; +>f18 : Symbol(f18, Decl(immediateCallbacks.ts, 109, 76)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 110, 21)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 110, 54)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 110, 21)) + +declare function f20(immediate ...funcs: Function[]): void; +>f20 : Symbol(f20, Decl(immediateCallbacks.ts, 110, 76)) +>funcs : Symbol(funcs, Decl(immediateCallbacks.ts, 112, 21)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) + +declare function f21 any)[]>(immediate ...funcs: T): void; +>f21 : Symbol(f21, Decl(immediateCallbacks.ts, 112, 59)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 113, 21)) +>args : Symbol(args, Decl(immediateCallbacks.ts, 113, 33)) +>funcs : Symbol(funcs, Decl(immediateCallbacks.ts, 113, 58)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 113, 21)) + +declare function f22 void))[]>(immediate ...funcs: T): void; +>f22 : Symbol(f22, Decl(immediateCallbacks.ts, 113, 87)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 114, 21)) +>funcs : Symbol(funcs, Decl(immediateCallbacks.ts, 114, 58)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 114, 21)) + +declare function f23 void)[]>(immediate ...funcs: T): void; +>f23 : Symbol(f23, Decl(immediateCallbacks.ts, 114, 87)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 115, 21)) +>funcs : Symbol(funcs, Decl(immediateCallbacks.ts, 115, 58)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 115, 21)) + +declare function f24 void)[]>(immediate ...funcs: T | string[]): void; +>f24 : Symbol(f24, Decl(immediateCallbacks.ts, 115, 87)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 116, 21)) +>funcs : Symbol(funcs, Decl(immediateCallbacks.ts, 116, 47)) +>T : Symbol(T, Decl(immediateCallbacks.ts, 116, 21)) + +declare function f30(immediate f: { foo(): void }): void; +>f30 : Symbol(f30, Decl(immediateCallbacks.ts, 116, 87)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 118, 21)) +>foo : Symbol(foo, Decl(immediateCallbacks.ts, 118, 35)) + +declare function f31(immediate f: number): void; +>f31 : Symbol(f31, Decl(immediateCallbacks.ts, 118, 57)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 119, 21)) + +declare function f32(immediate ...funcs: number[]): void; +>f32 : Symbol(f32, Decl(immediateCallbacks.ts, 119, 48)) +>funcs : Symbol(funcs, Decl(immediateCallbacks.ts, 120, 21)) + +type T10 = (immediate f: () => void) => void; +>T10 : Symbol(T10, Decl(immediateCallbacks.ts, 120, 57)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 122, 12)) + +type T11 = (immediate f: { (): void }) => void; +>T11 : Symbol(T11, Decl(immediateCallbacks.ts, 122, 45)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 123, 12)) + +type T12 = (immediate f: Function) => void; +>T12 : Symbol(T12, Decl(immediateCallbacks.ts, 123, 47)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 124, 12)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) + +type T13 = (immediate f: any) => void; +>T13 : Symbol(T13, Decl(immediateCallbacks.ts, 124, 43)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 125, 12)) + +type T20 = (immediate f: { foo(): void }) => void; +>T20 : Symbol(T20, Decl(immediateCallbacks.ts, 125, 38)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 127, 12)) +>foo : Symbol(foo, Decl(immediateCallbacks.ts, 127, 26)) + +type T21 = (immediate f: number) => void; +>T21 : Symbol(T21, Decl(immediateCallbacks.ts, 127, 50)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 128, 12)) + +type T22 = (immediate ...funcs: number[]) => void; +>T22 : Symbol(T22, Decl(immediateCallbacks.ts, 128, 41)) +>funcs : Symbol(funcs, Decl(immediateCallbacks.ts, 129, 12)) + +type T23 = { immediate x: () => void }; +>T23 : Symbol(T23, Decl(immediateCallbacks.ts, 129, 50)) +>x : Symbol(x, Decl(immediateCallbacks.ts, 130, 12)) + +// immediate modifier is not captured in argument list tuples + +declare function doStuff(immediate f: () => void): void; +>doStuff : Symbol(doStuff, Decl(immediateCallbacks.ts, 130, 39)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 134, 25)) + +declare function recreate(f: (...args: A) => R): (...args: A) => R; +>recreate : Symbol(recreate, Decl(immediateCallbacks.ts, 134, 56)) +>A : Symbol(A, Decl(immediateCallbacks.ts, 136, 26)) +>R : Symbol(R, Decl(immediateCallbacks.ts, 136, 46)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 136, 50)) +>args : Symbol(args, Decl(immediateCallbacks.ts, 136, 54)) +>A : Symbol(A, Decl(immediateCallbacks.ts, 136, 26)) +>R : Symbol(R, Decl(immediateCallbacks.ts, 136, 46)) +>args : Symbol(args, Decl(immediateCallbacks.ts, 136, 74)) +>A : Symbol(A, Decl(immediateCallbacks.ts, 136, 26)) +>R : Symbol(R, Decl(immediateCallbacks.ts, 136, 46)) + +declare function recreateImmediate1(f: (immediate ...args: A) => R): (...args: A) => R; +>recreateImmediate1 : Symbol(recreateImmediate1, Decl(immediateCallbacks.ts, 136, 91)) +>A : Symbol(A, Decl(immediateCallbacks.ts, 137, 36)) +>R : Symbol(R, Decl(immediateCallbacks.ts, 137, 56)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 137, 60)) +>args : Symbol(args, Decl(immediateCallbacks.ts, 137, 64)) +>A : Symbol(A, Decl(immediateCallbacks.ts, 137, 36)) +>R : Symbol(R, Decl(immediateCallbacks.ts, 137, 56)) +>args : Symbol(args, Decl(immediateCallbacks.ts, 137, 94)) +>A : Symbol(A, Decl(immediateCallbacks.ts, 137, 36)) +>R : Symbol(R, Decl(immediateCallbacks.ts, 137, 56)) + +declare function recreateImmediate2(f: (...args: A) => R): (immediate ...args: A) => R; +>recreateImmediate2 : Symbol(recreateImmediate2, Decl(immediateCallbacks.ts, 137, 111)) +>A : Symbol(A, Decl(immediateCallbacks.ts, 138, 36)) +>R : Symbol(R, Decl(immediateCallbacks.ts, 138, 56)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 138, 60)) +>args : Symbol(args, Decl(immediateCallbacks.ts, 138, 64)) +>A : Symbol(A, Decl(immediateCallbacks.ts, 138, 36)) +>R : Symbol(R, Decl(immediateCallbacks.ts, 138, 56)) +>args : Symbol(args, Decl(immediateCallbacks.ts, 138, 84)) +>A : Symbol(A, Decl(immediateCallbacks.ts, 138, 36)) +>R : Symbol(R, Decl(immediateCallbacks.ts, 138, 56)) + +function ff1() { +>ff1 : Symbol(ff1, Decl(immediateCallbacks.ts, 138, 111)) + + let x: string | number; +>x : Symbol(x, Decl(immediateCallbacks.ts, 141, 7)) + + x = 123; +>x : Symbol(x, Decl(immediateCallbacks.ts, 141, 7)) + + doStuff(() => { +>doStuff : Symbol(doStuff, Decl(immediateCallbacks.ts, 130, 39)) + + x = "hi"; +>x : Symbol(x, Decl(immediateCallbacks.ts, 141, 7)) + + }); + x; // string | number +>x : Symbol(x, Decl(immediateCallbacks.ts, 141, 7)) +} + +function ff2() { +>ff2 : Symbol(ff2, Decl(immediateCallbacks.ts, 147, 1)) + + let y: string | number; +>y : Symbol(y, Decl(immediateCallbacks.ts, 150, 7)) + + y = 123; +>y : Symbol(y, Decl(immediateCallbacks.ts, 150, 7)) + + recreate(doStuff)(() => { +>recreate : Symbol(recreate, Decl(immediateCallbacks.ts, 134, 56)) +>doStuff : Symbol(doStuff, Decl(immediateCallbacks.ts, 130, 39)) + + y = "hi"; +>y : Symbol(y, Decl(immediateCallbacks.ts, 150, 7)) + + }); + y; // number +>y : Symbol(y, Decl(immediateCallbacks.ts, 150, 7)) +} + +function ff3() { +>ff3 : Symbol(ff3, Decl(immediateCallbacks.ts, 156, 1)) + + let z: string | number; +>z : Symbol(z, Decl(immediateCallbacks.ts, 159, 7)) + + z = 123; +>z : Symbol(z, Decl(immediateCallbacks.ts, 159, 7)) + + recreateImmediate1(doStuff)(() => { +>recreateImmediate1 : Symbol(recreateImmediate1, Decl(immediateCallbacks.ts, 136, 91)) +>doStuff : Symbol(doStuff, Decl(immediateCallbacks.ts, 130, 39)) + + z = "hi"; +>z : Symbol(z, Decl(immediateCallbacks.ts, 159, 7)) + + }); + z; // number +>z : Symbol(z, Decl(immediateCallbacks.ts, 159, 7)) +} + +function ff4() { +>ff4 : Symbol(ff4, Decl(immediateCallbacks.ts, 165, 1)) + + let z: string | number; +>z : Symbol(z, Decl(immediateCallbacks.ts, 168, 7)) + + z = 123; +>z : Symbol(z, Decl(immediateCallbacks.ts, 168, 7)) + + recreateImmediate2(doStuff)(() => { +>recreateImmediate2 : Symbol(recreateImmediate2, Decl(immediateCallbacks.ts, 137, 111)) +>doStuff : Symbol(doStuff, Decl(immediateCallbacks.ts, 130, 39)) + + z = "hi"; +>z : Symbol(z, Decl(immediateCallbacks.ts, 168, 7)) + + }); + z; // string | number +>z : Symbol(z, Decl(immediateCallbacks.ts, 168, 7)) +} + +// https://github.com/microsoft/TypeScript/issues/11498 + +declare function mystery(immediate cb: () => void): void; +>mystery : Symbol(mystery, Decl(immediateCallbacks.ts, 174, 1)) +>cb : Symbol(cb, Decl(immediateCallbacks.ts, 178, 25)) + +function fx1() { +>fx1 : Symbol(fx1, Decl(immediateCallbacks.ts, 178, 57)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(immediateCallbacks.ts, 181, 7)) + + x; // string +>x : Symbol(x, Decl(immediateCallbacks.ts, 181, 7)) + + mystery(() => { +>mystery : Symbol(mystery, Decl(immediateCallbacks.ts, 174, 1)) + + x = 10; +>x : Symbol(x, Decl(immediateCallbacks.ts, 181, 7)) + + }); + x; // string | number +>x : Symbol(x, Decl(immediateCallbacks.ts, 181, 7)) + + if (x === 10) {} +>x : Symbol(x, Decl(immediateCallbacks.ts, 181, 7)) +} + +// https://github.com/microsoft/TypeScript/issues/15380 + +class Foo { +>Foo : Symbol(Foo, Decl(immediateCallbacks.ts, 188, 1)) + + public bar: string = ""; +>bar : Symbol(Foo.bar, Decl(immediateCallbacks.ts, 192, 11)) +} + +function fx2() { +>fx2 : Symbol(fx2, Decl(immediateCallbacks.ts, 194, 1)) + + let foo: Foo | null = null; +>foo : Symbol(foo, Decl(immediateCallbacks.ts, 197, 5)) +>Foo : Symbol(Foo, Decl(immediateCallbacks.ts, 188, 1)) + + [1].forEach((item) => { +>[1].forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --)) +>forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --)) +>item : Symbol(item, Decl(immediateCallbacks.ts, 198, 15)) + + foo = new Foo(); +>foo : Symbol(foo, Decl(immediateCallbacks.ts, 197, 5)) +>Foo : Symbol(Foo, Decl(immediateCallbacks.ts, 188, 1)) + + }); + if (foo) { +>foo : Symbol(foo, Decl(immediateCallbacks.ts, 197, 5)) + + foo.bar; +>foo.bar : Symbol(Foo.bar, Decl(immediateCallbacks.ts, 192, 11)) +>foo : Symbol(foo, Decl(immediateCallbacks.ts, 197, 5)) +>bar : Symbol(Foo.bar, Decl(immediateCallbacks.ts, 192, 11)) + } +} + +// https://github.com/microsoft/TypeScript/issues/57880 + +const call = (immediate f: () => void) => f(); +>call : Symbol(call, Decl(immediateCallbacks.ts, 208, 5)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 208, 14)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 208, 14)) + +const fx3 = () => { +>fx3 : Symbol(fx3, Decl(immediateCallbacks.ts, 210, 5)) + + let a: undefined | number = undefined; +>a : Symbol(a, Decl(immediateCallbacks.ts, 211, 7)) +>undefined : Symbol(undefined) + + call(() => { a = 1; }); +>call : Symbol(call, Decl(immediateCallbacks.ts, 208, 5)) +>a : Symbol(a, Decl(immediateCallbacks.ts, 211, 7)) + + if (a !== undefined) { +>a : Symbol(a, Decl(immediateCallbacks.ts, 211, 7)) +>undefined : Symbol(undefined) + + a.toString(); +>a.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(immediateCallbacks.ts, 211, 7)) +>toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) + } +}; + +// https://github.com/microsoft/TypeScript/issues/58291 + +async function execute(immediate onError: (_err: Error | undefined) => void) { +>execute : Symbol(execute, Decl(immediateCallbacks.ts, 216, 2)) +>onError : Symbol(onError, Decl(immediateCallbacks.ts, 220, 23)) +>_err : Symbol(_err, Decl(immediateCallbacks.ts, 220, 43)) +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) + + onError(new Error("a")); +>onError : Symbol(onError, Decl(immediateCallbacks.ts, 220, 23)) +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) +} + +async function run() { +>run : Symbol(run, Decl(immediateCallbacks.ts, 222, 1)) + + let result: boolean = true; +>result : Symbol(result, Decl(immediateCallbacks.ts, 225, 7)) + + await execute(() => { +>execute : Symbol(execute, Decl(immediateCallbacks.ts, 216, 2)) + + result = false; +>result : Symbol(result, Decl(immediateCallbacks.ts, 225, 7)) + + }); + if (result === false) { +>result : Symbol(result, Decl(immediateCallbacks.ts, 225, 7)) + + console.log("error"); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) + } + return result; +>result : Symbol(result, Decl(immediateCallbacks.ts, 225, 7)) +} + diff --git a/tests/baselines/reference/immediateCallbacks.types b/tests/baselines/reference/immediateCallbacks.types new file mode 100644 index 0000000000000..43d2021c6e5f4 --- /dev/null +++ b/tests/baselines/reference/immediateCallbacks.types @@ -0,0 +1,1031 @@ +//// [tests/cases/compiler/immediateCallbacks.ts] //// + +=== immediateCallbacks.ts === +declare function deferred(cb: () => void): void; +>deferred : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>cb : () => void +> : ^^^^^^ + +declare function immediate1(immediate cb: () => void): void; +>immediate1 : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>cb : () => void +> : ^^^^^^ + +declare function immediate2(/** @immediate */ cb: () => void): void; +>immediate2 : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>cb : () => void +> : ^^^^^^ + +declare function immediate3(/** @immediate */ immediate cb: () => void): void; +>immediate3 : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>cb : () => void +> : ^^^^^^ + +function f01() { +>f01 : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + deferred(() => { +>deferred(() => { x = 42; }) : void +> : ^^^^ +>deferred : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = 42; } : () => void +> : ^^^^^^^^^^ + + x = 42; +>x = 42 : 42 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + }); + x; // string +>x : string +> : ^^^^^^ +} + +function f02() { +>f02 : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + immediate1(() => { +>immediate1(() => { x = 42; }) : void +> : ^^^^ +>immediate1 : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = 42; } : () => void +> : ^^^^^^^^^^ + + x = 42; +>x = 42 : 42 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + }); + x; // string | number +>x : string | number +> : ^^^^^^^^^^^^^^^ +} + +function f03() { +>f03 : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + immediate2(() => { +>immediate2(() => { x = 42; }) : void +> : ^^^^ +>immediate2 : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = 42; } : () => void +> : ^^^^^^^^^^ + + x = 42; +>x = 42 : 42 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + }); + x; // string | number +>x : string | number +> : ^^^^^^^^^^^^^^^ +} + +function f04() { +>f04 : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + immediate3(() => { +>immediate3(() => { x = 42; }) : void +> : ^^^^ +>immediate3 : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = 42; } : () => void +> : ^^^^^^^^^^ + + x = 42; +>x = 42 : 42 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + }); + x; // string | number +>x : string | number +> : ^^^^^^^^^^^^^^^ +} + +// Parameter is considered immediate if one or more overloads include the modifier in that parameter position + +declare function overloaded(cb: (x: T) => T): void; +>overloaded : { (cb: (x: T) => T): void; (cb: (x: T_1, y: T_1) => T_1): void; (cb: (...args: any) => any): void; } +> : ^^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ +>cb : (x: T) => T +> : ^ ^^ ^^^^^ +>x : T +> : ^ + +declare function overloaded(cb: (x: T, y: T) => T): void; +>overloaded : { (cb: (x: T_1) => T_1): void; (cb: (x: T, y: T) => T): void; (cb: (...args: any) => any): void; } +> : ^^^^^^^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ +>cb : (x: T, y: T) => T +> : ^ ^^ ^^ ^^ ^^^^^ +>x : T +> : ^ +>y : T +> : ^ + +declare function overloaded(immediate cb: (...args: any) => any): void; +>overloaded : { (cb: (x: T) => T): void; (cb: (x: T, y: T) => T): void; (cb: (...args: any) => any): void; } +> : ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ +>cb : (...args: any) => any +> : ^^^^ ^^ ^^^^^ +>args : any +> : ^^^ + +function f05() { +>f05 : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + overloaded(() => { +>overloaded(() => { x = 42; }) : void +> : ^^^^ +>overloaded : { (cb: (x: T) => T): void; (cb: (x: T, y: T) => T): void; (cb: (...args: any) => any): void; } +> : ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ +>() => { x = 42; } : () => void +> : ^^^^^^^^^^ + + x = 42; +>x = 42 : 42 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + }); + x; // string | number +>x : string | number +> : ^^^^^^^^^^^^^^^ +} + +// immediate is permitted on a rest parameter + +declare function invokeDeferred(...args: ((...args: any) => any)[]): void; +>invokeDeferred : (...args: ((...args: any) => any)[]) => void +> : ^^^^ ^^ ^^^^^ +>args : ((...args: any) => any)[] +> : ^^^^^ ^^ ^^^^^ ^^^ +>args : any +> : ^^^ + +declare function invokeImmediate(immediate ...args: ((...args: any) => any)[]): void; +>invokeImmediate : (...args: ((...args: any) => any)[]) => void +> : ^^^^ ^^ ^^^^^ +>args : ((...args: any) => any)[] +> : ^^^^^ ^^ ^^^^^ ^^^ +>args : any +> : ^^^ + +function f06() { +>f06 : () => void +> : ^^^^^^^^^^ + + let a = []; +>a : any[] +> : ^^^^^ +>[] : never[] +> : ^^^^^^^ + + a.push("abc"); +>a.push("abc") : number +> : ^^^^^^ +>a.push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>a : any[] +> : ^^^^^ +>push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>"abc" : "abc" +> : ^^^^^ + + a; // string[] +>a : string[] +> : ^^^^^^^^ + + invokeImmediate( +>invokeImmediate( () => { a; // string[] a.push(42); a; // (string | number)[] }, () => { a; // string[] a.push(true); a; // (string | boolean)[] } ) : void +> : ^^^^ +>invokeImmediate : (...args: ((...args: any) => any)[]) => void +> : ^^^^ ^^ ^^^^^ + + () => { +>() => { a; // string[] a.push(42); a; // (string | number)[] } : () => void +> : ^^^^^^^^^^ + + a; // string[] +>a : string[] +> : ^^^^^^^^ + + a.push(42); +>a.push(42) : number +> : ^^^^^^ +>a.push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>a : any[] +> : ^^^^^ +>push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + a; // (string | number)[] +>a : (string | number)[] +> : ^^^^^^^^^^^^^^^^^^^ + + }, + () => { +>() => { a; // string[] a.push(true); a; // (string | boolean)[] } : () => void +> : ^^^^^^^^^^ + + a; // string[] +>a : string[] +> : ^^^^^^^^ + + a.push(true); +>a.push(true) : number +> : ^^^^^^ +>a.push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>a : any[] +> : ^^^^^ +>push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>true : true +> : ^^^^ + + a; // (string | boolean)[] +>a : (string | boolean)[] +> : ^^^^^^^^^^^^^^^^^^^^ + } + ); + a; // (string | number | boolean)[] +>a : (string | number | boolean)[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +} + +function f07() { +>f07 : () => void +> : ^^^^^^^^^^ + + let a = []; +>a : any[] +> : ^^^^^ +>[] : never[] +> : ^^^^^^^ + + a.push("abc"); +>a.push("abc") : number +> : ^^^^^^ +>a.push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>a : any[] +> : ^^^^^ +>push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>"abc" : "abc" +> : ^^^^^ + + a; // string[] +>a : string[] +> : ^^^^^^^^ + + invokeDeferred( +>invokeDeferred( () => { a; // string[] a.push(42); a; // (string | number)[] }, () => { a; // string[] a.push(true); a; // (string | boolean)[] } ) : void +> : ^^^^ +>invokeDeferred : (...args: ((...args: any) => any)[]) => void +> : ^^^^ ^^ ^^^^^ + + () => { +>() => { a; // string[] a.push(42); a; // (string | number)[] } : () => void +> : ^^^^^^^^^^ + + a; // string[] +>a : string[] +> : ^^^^^^^^ + + a.push(42); +>a.push(42) : number +> : ^^^^^^ +>a.push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>a : any[] +> : ^^^^^ +>push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>42 : 42 +> : ^^ + + a; // (string | number)[] +>a : (string | number)[] +> : ^^^^^^^^^^^^^^^^^^^ + + }, + () => { +>() => { a; // string[] a.push(true); a; // (string | boolean)[] } : () => void +> : ^^^^^^^^^^ + + a; // string[] +>a : string[] +> : ^^^^^^^^ + + a.push(true); +>a.push(true) : number +> : ^^^^^^ +>a.push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>a : any[] +> : ^^^^^ +>push : (...items: any[]) => number +> : ^^^^ ^^^^^^^^^^^^ +>true : true +> : ^^^^ + + a; // (string | boolean)[] +>a : (string | boolean)[] +> : ^^^^^^^^^^^^^^^^^^^^ + } + ); + a; // string[] +>a : string[] +> : ^^^^^^^^ +} + +// immediate modifier must precede public/private/protected/readonly + +class CC { +>CC : CC +> : ^^ + + constructor(immediate public readonly x: () => void) {} +>x : () => void +> : ^^^^^^ +} + +// immediate requires parameter to have type that permits functions + +declare function f10(immediate f: () => void): void; +>f10 : (f: () => void) => void +> : ^ ^^ ^^^^^ +>f : () => void +> : ^^^^^^ + +declare function f11(immediate f: Function): void; +>f11 : (f: Function) => void +> : ^ ^^ ^^^^^ +>f : Function +> : ^^^^^^^^ + +declare function f12(immediate f: any): void; +>f12 : (f: any) => void +> : ^ ^^ ^^^^^ +>f : any +> : ^^^ + +declare function f13(immediate f: object): void; +>f13 : (f: object) => void +> : ^ ^^ ^^^^^ +>f : object +> : ^^^^^^ + +declare function f14(immediate f: {}): void; +>f14 : (f: {}) => void +> : ^ ^^ ^^^^^ +>f : {} +> : ^^ + +declare function f15(immediate f: unknown): void; +>f15 : (f: unknown) => void +> : ^ ^^ ^^^^^ +>f : unknown +> : ^^^^^^^ + +declare function f16(immediate f: T): void; +>f16 : (f: T) => void +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>f : T +> : ^ + +declare function f17 any>(immediate f: T): void; +>f17 : any>(f: T) => void +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>args : any +> : ^^^ +>f : T +> : ^ + +declare function f18 void)>(immediate f: T): void; +>f18 : void)>(f: T) => void +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>f : T +> : ^ + +declare function f20(immediate ...funcs: Function[]): void; +>f20 : (...funcs: Function[]) => void +> : ^^^^ ^^ ^^^^^ +>funcs : Function[] +> : ^^^^^^^^^^ + +declare function f21 any)[]>(immediate ...funcs: T): void; +>f21 : any)[]>(...funcs: T) => void +> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ +>args : any +> : ^^^ +>funcs : T +> : ^ + +declare function f22 void))[]>(immediate ...funcs: T): void; +>f22 : void))[]>(...funcs: T) => void +> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ +>funcs : T +> : ^ + +declare function f23 void)[]>(immediate ...funcs: T): void; +>f23 : void)[]>(...funcs: T) => void +> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ +>funcs : T +> : ^ + +declare function f24 void)[]>(immediate ...funcs: T | string[]): void; +>f24 : void)[]>(...funcs: T | string[]) => void +> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ +>funcs : string[] | T +> : ^^^^^^^^^^^^ + +declare function f30(immediate f: { foo(): void }): void; +>f30 : (f: { foo(): void; }) => void +> : ^ ^^ ^^^^^ +>f : { foo(): void; } +> : ^^^^^^^^^ ^^^ +>foo : () => void +> : ^^^^^^ + +declare function f31(immediate f: number): void; +>f31 : (f: number) => void +> : ^ ^^ ^^^^^ +>f : number +> : ^^^^^^ + +declare function f32(immediate ...funcs: number[]): void; +>f32 : (...funcs: number[]) => void +> : ^^^^ ^^ ^^^^^ +>funcs : number[] +> : ^^^^^^^^ + +type T10 = (immediate f: () => void) => void; +>T10 : T10 +> : ^^^ +>f : () => void +> : ^^^^^^ + +type T11 = (immediate f: { (): void }) => void; +>T11 : T11 +> : ^^^ +>f : () => void +> : ^^^^^^ + +type T12 = (immediate f: Function) => void; +>T12 : T12 +> : ^^^ +>f : Function +> : ^^^^^^^^ + +type T13 = (immediate f: any) => void; +>T13 : T13 +> : ^^^ +>f : any +> : ^^^ + +type T20 = (immediate f: { foo(): void }) => void; +>T20 : T20 +> : ^^^ +>f : { foo(): void; } +> : ^^^^^^^^^ ^^^ +>foo : () => void +> : ^^^^^^ + +type T21 = (immediate f: number) => void; +>T21 : T21 +> : ^^^ +>f : number +> : ^^^^^^ + +type T22 = (immediate ...funcs: number[]) => void; +>T22 : T22 +> : ^^^ +>funcs : number[] +> : ^^^^^^^^ + +type T23 = { immediate x: () => void }; +>T23 : T23 +> : ^^^ +>x : () => void +> : ^^^^^^ + +// immediate modifier is not captured in argument list tuples + +declare function doStuff(immediate f: () => void): void; +>doStuff : (f: () => void) => void +> : ^ ^^ ^^^^^ +>f : () => void +> : ^^^^^^ + +declare function recreate(f: (...args: A) => R): (...args: A) => R; +>recreate : (f: (...args: A) => R) => (...args: A) => R +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>f : (...args: A) => R +> : ^^^^ ^^ ^^^^^ +>args : A +> : ^ +>args : A +> : ^ + +declare function recreateImmediate1(f: (immediate ...args: A) => R): (...args: A) => R; +>recreateImmediate1 : (f: (immediate ...args: A) => R) => (...args: A) => R +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>f : (...args: A) => R +> : ^^^^ ^^ ^^^^^ +>args : A +> : ^ +>args : A +> : ^ + +declare function recreateImmediate2(f: (...args: A) => R): (immediate ...args: A) => R; +>recreateImmediate2 : (f: (...args: A) => R) => (immediate ...args: A) => R +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>f : (...args: A) => R +> : ^^^^ ^^ ^^^^^ +>args : A +> : ^ +>args : A +> : ^ + +function ff1() { +>ff1 : () => void +> : ^^^^^^^^^^ + + let x: string | number; +>x : string | number +> : ^^^^^^^^^^^^^^^ + + x = 123; +>x = 123 : 123 +> : ^^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>123 : 123 +> : ^^^ + + doStuff(() => { +>doStuff(() => { x = "hi"; }) : void +> : ^^^^ +>doStuff : (f: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = "hi"; } : () => void +> : ^^^^^^^^^^ + + x = "hi"; +>x = "hi" : "hi" +> : ^^^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"hi" : "hi" +> : ^^^^ + + }); + x; // string | number +>x : string | number +> : ^^^^^^^^^^^^^^^ +} + +function ff2() { +>ff2 : () => void +> : ^^^^^^^^^^ + + let y: string | number; +>y : string | number +> : ^^^^^^^^^^^^^^^ + + y = 123; +>y = 123 : 123 +> : ^^^ +>y : string | number +> : ^^^^^^^^^^^^^^^ +>123 : 123 +> : ^^^ + + recreate(doStuff)(() => { +>recreate(doStuff)(() => { y = "hi"; }) : void +> : ^^^^ +>recreate(doStuff) : (f: () => void) => void +> : ^^^^^^^^^^ ^^^^^^^^^ +>recreate : (f: (...args: A) => R) => (...args: A) => R +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>doStuff : (f: () => void) => void +> : ^ ^^ ^^^^^ +>() => { y = "hi"; } : () => void +> : ^^^^^^^^^^ + + y = "hi"; +>y = "hi" : "hi" +> : ^^^^ +>y : string | number +> : ^^^^^^^^^^^^^^^ +>"hi" : "hi" +> : ^^^^ + + }); + y; // number +>y : number +> : ^^^^^^ +} + +function ff3() { +>ff3 : () => void +> : ^^^^^^^^^^ + + let z: string | number; +>z : string | number +> : ^^^^^^^^^^^^^^^ + + z = 123; +>z = 123 : 123 +> : ^^^ +>z : string | number +> : ^^^^^^^^^^^^^^^ +>123 : 123 +> : ^^^ + + recreateImmediate1(doStuff)(() => { +>recreateImmediate1(doStuff)(() => { z = "hi"; }) : void +> : ^^^^ +>recreateImmediate1(doStuff) : (f: () => void) => void +> : ^^^^^^^^^^ ^^^^^^^^^ +>recreateImmediate1 : (f: (immediate ...args: A) => R) => (...args: A) => R +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>doStuff : (f: () => void) => void +> : ^ ^^ ^^^^^ +>() => { z = "hi"; } : () => void +> : ^^^^^^^^^^ + + z = "hi"; +>z = "hi" : "hi" +> : ^^^^ +>z : string | number +> : ^^^^^^^^^^^^^^^ +>"hi" : "hi" +> : ^^^^ + + }); + z; // number +>z : number +> : ^^^^^^ +} + +function ff4() { +>ff4 : () => void +> : ^^^^^^^^^^ + + let z: string | number; +>z : string | number +> : ^^^^^^^^^^^^^^^ + + z = 123; +>z = 123 : 123 +> : ^^^ +>z : string | number +> : ^^^^^^^^^^^^^^^ +>123 : 123 +> : ^^^ + + recreateImmediate2(doStuff)(() => { +>recreateImmediate2(doStuff)(() => { z = "hi"; }) : void +> : ^^^^ +>recreateImmediate2(doStuff) : (f: () => void) => void +> : ^^^^^^^^^^ ^^^^^^^^^ +>recreateImmediate2 : (f: (...args: A) => R) => (immediate ...args: A) => R +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>doStuff : (f: () => void) => void +> : ^ ^^ ^^^^^ +>() => { z = "hi"; } : () => void +> : ^^^^^^^^^^ + + z = "hi"; +>z = "hi" : "hi" +> : ^^^^ +>z : string | number +> : ^^^^^^^^^^^^^^^ +>"hi" : "hi" +> : ^^^^ + + }); + z; // string | number +>z : string | number +> : ^^^^^^^^^^^^^^^ +} + +// https://github.com/microsoft/TypeScript/issues/11498 + +declare function mystery(immediate cb: () => void): void; +>mystery : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>cb : () => void +> : ^^^^^^ + +function fx1() { +>fx1 : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + x; // string +>x : string +> : ^^^^^^ + + mystery(() => { +>mystery(() => { x = 10; }) : void +> : ^^^^ +>mystery : (cb: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = 10; } : () => void +> : ^^^^^^^^^^ + + x = 10; +>x = 10 : 10 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>10 : 10 +> : ^^ + + }); + x; // string | number +>x : string | number +> : ^^^^^^^^^^^^^^^ + + if (x === 10) {} +>x === 10 : boolean +> : ^^^^^^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>10 : 10 +> : ^^ +} + +// https://github.com/microsoft/TypeScript/issues/15380 + +class Foo { +>Foo : Foo +> : ^^^ + + public bar: string = ""; +>bar : string +> : ^^^^^^ +>"" : "" +> : ^^ +} + +function fx2() { +>fx2 : () => void +> : ^^^^^^^^^^ + + let foo: Foo | null = null; +>foo : Foo | null +> : ^^^^^^^^^^ + + [1].forEach((item) => { +>[1].forEach((item) => { foo = new Foo(); }) : void +> : ^^^^ +>[1].forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void +> : ^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ +>[1] : number[] +> : ^^^^^^^^ +>1 : 1 +> : ^ +>forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void +> : ^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ +>(item) => { foo = new Foo(); } : (item: number) => void +> : ^ ^^^^^^^^^^^^^^^^^ +>item : number +> : ^^^^^^ + + foo = new Foo(); +>foo = new Foo() : Foo +> : ^^^ +>foo : Foo | null +> : ^^^^^^^^^^ +>new Foo() : Foo +> : ^^^ +>Foo : typeof Foo +> : ^^^^^^^^^^ + + }); + if (foo) { +>foo : Foo | null +> : ^^^^^^^^^^ + + foo.bar; +>foo.bar : string +> : ^^^^^^ +>foo : Foo +> : ^^^ +>bar : string +> : ^^^^^^ + } +} + +// https://github.com/microsoft/TypeScript/issues/57880 + +const call = (immediate f: () => void) => f(); +>call : (f: () => void) => void +> : ^ ^^ ^^^^^^^^^ +>(immediate f: () => void) => f() : (f: () => void) => void +> : ^ ^^ ^^^^^^^^^ +>f : () => void +> : ^^^^^^ +>f() : void +> : ^^^^ +>f : () => void +> : ^^^^^^ + +const fx3 = () => { +>fx3 : () => void +> : ^^^^^^^^^^ +>() => { let a: undefined | number = undefined; call(() => { a = 1; }); if (a !== undefined) { a.toString(); }} : () => void +> : ^^^^^^^^^^ + + let a: undefined | number = undefined; +>a : number | undefined +> : ^^^^^^^^^^^^^^^^^^ +>undefined : undefined +> : ^^^^^^^^^ + + call(() => { a = 1; }); +>call(() => { a = 1; }) : void +> : ^^^^ +>call : (f: () => void) => void +> : ^ ^^ ^^^^^^^^^ +>() => { a = 1; } : () => void +> : ^^^^^^^^^^ +>a = 1 : 1 +> : ^ +>a : number | undefined +> : ^^^^^^^^^^^^^^^^^^ +>1 : 1 +> : ^ + + if (a !== undefined) { +>a !== undefined : boolean +> : ^^^^^^^ +>a : number | undefined +> : ^^^^^^^^^^^^^^^^^^ +>undefined : undefined +> : ^^^^^^^^^ + + a.toString(); +>a.toString() : string +> : ^^^^^^ +>a.toString : (radix?: number) => string +> : ^ ^^^ ^^^^^ +>a : number +> : ^^^^^^ +>toString : (radix?: number) => string +> : ^ ^^^ ^^^^^ + } +}; + +// https://github.com/microsoft/TypeScript/issues/58291 + +async function execute(immediate onError: (_err: Error | undefined) => void) { +>execute : (onError: (_err: Error | undefined) => void) => Promise +> : ^ ^^ ^^^^^^^^^^^^^^^^^^ +>onError : (_err: Error | undefined) => void +> : ^ ^^ ^^^^^ +>_err : Error | undefined +> : ^^^^^^^^^^^^^^^^^ + + onError(new Error("a")); +>onError(new Error("a")) : void +> : ^^^^ +>onError : (_err: Error | undefined) => void +> : ^ ^^ ^^^^^ +>new Error("a") : Error +> : ^^^^^ +>Error : ErrorConstructor +> : ^^^^^^^^^^^^^^^^ +>"a" : "a" +> : ^^^ +} + +async function run() { +>run : () => Promise +> : ^^^^^^^^^^^^^^^^^^^^^^ + + let result: boolean = true; +>result : boolean +> : ^^^^^^^ +>true : true +> : ^^^^ + + await execute(() => { +>await execute(() => { result = false; }) : void +> : ^^^^ +>execute(() => { result = false; }) : Promise +> : ^^^^^^^^^^^^^ +>execute : (onError: (_err: Error | undefined) => void) => Promise +> : ^ ^^ ^^^^^^^^^^^^^^^^^^ +>() => { result = false; } : () => void +> : ^^^^^^^^^^ + + result = false; +>result = false : false +> : ^^^^^ +>result : boolean +> : ^^^^^^^ +>false : false +> : ^^^^^ + + }); + if (result === false) { +>result === false : boolean +> : ^^^^^^^ +>result : boolean +> : ^^^^^^^ +>false : false +> : ^^^^^ + + console.log("error"); +>console.log("error") : void +> : ^^^^ +>console.log : (...data: any[]) => void +> : ^^^^ ^^ ^^^^^ +>console : Console +> : ^^^^^^^ +>log : (...data: any[]) => void +> : ^^^^ ^^ ^^^^^ +>"error" : "error" +> : ^^^^^^^ + } + return result; +>result : boolean +> : ^^^^^^^ +} + diff --git a/tests/baselines/reference/parserharness.types b/tests/baselines/reference/parserharness.types index 8bc16b33edfdd..0326d8453ba19 100644 --- a/tests/baselines/reference/parserharness.types +++ b/tests/baselines/reference/parserharness.types @@ -1838,8 +1838,8 @@ module Harness { }); return isAsync; ->isAsync : boolean -> : ^^^^^^^ +>isAsync : true +> : ^^^^ } } catch (e) { diff --git a/tests/baselines/reference/parserindenter.types b/tests/baselines/reference/parserindenter.types index 02d35ccb26511..0d93f460d18e4 100644 --- a/tests/baselines/reference/parserindenter.types +++ b/tests/baselines/reference/parserindenter.types @@ -2328,8 +2328,8 @@ module Formatting { }); return result; ->result : boolean -> : ^^^^^^^ +>result : true +> : ^^^^ } return false; From 22faf4e39a57f50724f878b0f4c0770a1ab53685 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Thu, 8 Aug 2024 12:17:19 -0700 Subject: [PATCH 28/30] Delete old test baselines --- .../reference/deferredCallbacks.errors.txt | 259 ----- .../baselines/reference/deferredCallbacks.js | 464 -------- .../reference/deferredCallbacks.symbols | 627 ---------- .../reference/deferredCallbacks.types | 1035 ----------------- 4 files changed, 2385 deletions(-) delete mode 100644 tests/baselines/reference/deferredCallbacks.errors.txt delete mode 100644 tests/baselines/reference/deferredCallbacks.js delete mode 100644 tests/baselines/reference/deferredCallbacks.symbols delete mode 100644 tests/baselines/reference/deferredCallbacks.types diff --git a/tests/baselines/reference/deferredCallbacks.errors.txt b/tests/baselines/reference/deferredCallbacks.errors.txt deleted file mode 100644 index 7a8b89a16d882..0000000000000 --- a/tests/baselines/reference/deferredCallbacks.errors.txt +++ /dev/null @@ -1,259 +0,0 @@ -deferredCallbacks.ts(119,22): error TS2874: A 'deferred' parameter must have a type that permits functions. -deferredCallbacks.ts(120,22): error TS2874: A 'deferred' parameter must have a type that permits functions. -deferredCallbacks.ts(121,22): error TS2874: A 'deferred' parameter must have a type that permits functions. -deferredCallbacks.ts(128,13): error TS2874: A 'deferred' parameter must have a type that permits functions. -deferredCallbacks.ts(129,13): error TS2874: A 'deferred' parameter must have a type that permits functions. -deferredCallbacks.ts(130,13): error TS2874: A 'deferred' parameter must have a type that permits functions. -deferredCallbacks.ts(131,14): error TS1070: 'deferred' modifier cannot appear on a type member. - - -==== deferredCallbacks.ts (7 errors) ==== - declare function immediate(cb: () => void): void; - declare function deferred1(deferred cb: () => void): void; - declare function deferred2(/** @deferred */ cb: () => void): void; - declare function deferred3(/** @deferred */ deferred cb: () => void): void; - - function f01() { - let x: string | number = "OK"; - immediate(() => { - x = 42; - }); - x; // string | number - } - - function f02() { - let x: string | number = "OK"; - deferred1(() => { - x = 42; - }); - x; // string - } - - function f03() { - let x: string | number = "OK"; - deferred2(() => { - x = 42; - }); - x; // string - } - - function f04() { - let x: string | number = "OK"; - deferred3(() => { - x = 42; - }); - x; // string - } - - // Parameter is considered deferred if one or more overloads defer that parameter - - declare function overloaded(cb: (x: T) => T): void; - declare function overloaded(cb: (x: T, y: T) => T): void; - declare function overloaded(deferred cb: (...args: any) => any): void; - - function f05() { - let x: string | number = "OK"; - overloaded(() => { - x = 42; - }); - x.length; - } - - // deferred is permitted on a rest parameter - - declare function invokeImmediate(...args: ((...args: any) => any)[]): void; - declare function invokeDeferred(deferred ...args: ((...args: any) => any)[]): void; - - function f06() { - let a = []; - a.push("abc"); - a; // string[] - invokeImmediate( - () => { - a; // string[] - a.push(42); - a; // (string | number)[] - }, - () => { - a; // string[] - a.push(true); - a; // (string | boolean)[] - } - ); - a; // (string | number | boolean)[] - } - - function f07() { - let a = []; - a.push("abc"); - a; // string[] - invokeDeferred( - () => { - a; // string[] - a.push(42); - a; // (string | number)[] - }, - () => { - a; // string[] - a.push(true); - a; // (string | boolean)[] - } - ); - a; // string[] - } - - // deferred modifier must precede public/private/protected/readonly - - class CC { - constructor(deferred public readonly x: () => void) {} - } - - // deferred requires parameter to have type that permits functions - - declare function f10(deferred f: () => void): void; - declare function f11(deferred f: Function): void; - declare function f12(deferred f: any): void; - declare function f13(deferred f: object): void; - declare function f14(deferred f: {}): void; - declare function f15(deferred f: unknown): void; - declare function f16(deferred f: T): void; - declare function f17 any>(deferred f: T): void; - declare function f18 void)>(deferred f: T): void; - - declare function f20(deferred ...funcs: Function[]): void; - declare function f21 any)[]>(deferred ...funcs: T): void; - declare function f22 void))[]>(deferred ...funcs: T): void; - declare function f23 void)[]>(deferred ...funcs: T): void; - declare function f24 void)[]>(deferred ...funcs: T | string[]): void; - - declare function f30(deferred f: { foo(): void }): void; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2874: A 'deferred' parameter must have a type that permits functions. - declare function f31(deferred f: number): void; - ~~~~~~~~~~~~~~~~~~ -!!! error TS2874: A 'deferred' parameter must have a type that permits functions. - declare function f32(deferred ...funcs: number[]): void; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2874: A 'deferred' parameter must have a type that permits functions. - - type T10 = (deferred f: () => void) => void; - type T11 = (deferred f: { (): void }) => void; - type T12 = (deferred f: Function) => void; - type T13 = (deferred f: any) => void; - - type T20 = (deferred f: { foo(): void }) => void; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2874: A 'deferred' parameter must have a type that permits functions. - type T21 = (deferred f: number) => void; - ~~~~~~~~~~~~~~~~~~ -!!! error TS2874: A 'deferred' parameter must have a type that permits functions. - type T22 = (deferred ...funcs: number[]) => void; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2874: A 'deferred' parameter must have a type that permits functions. - type T23 = { deferred x: () => void }; - ~~~~~~~~ -!!! error TS1070: 'deferred' modifier cannot appear on a type member. - - // deferred modifier is not captured in argument list tuples - - declare function doStuff(deferred f: () => void): void; - - declare function recreate(f: (...args: A) => R): (...args: A) => R; - declare function recreateDeferred1(f: (deferred ...args: A) => R): (...args: A) => R; - declare function recreateDeferred2(f: (...args: A) => R): (deferred ...args: A) => R; - - function ff1() { - let x: string | number; - x = 123; - doStuff(() => { - x = "hi"; - }); - x; // number - } - - function ff2() { - let y: string | number; - y = 123; - recreate(doStuff)(() => { - y = "hi"; - }); - y; // string | number - } - - function ff3() { - let z: string | number; - z = 123; - recreateDeferred1(doStuff)(() => { - z = "hi"; - }); - z; // string | number - } - - function ff4() { - let z: string | number; - z = 123; - recreateDeferred2(doStuff)(() => { - z = "hi"; - }); - z; // number - } - - // https://github.com/microsoft/TypeScript/issues/11498 - - declare function mystery(cb: () => void): void; - - function fx1() { - let x: string | number = "OK"; - x; // string - mystery(() => { - x = 10; - }); - x; // string | number - if (x === 10) {} - } - - // https://github.com/microsoft/TypeScript/issues/15380 - - class Foo { - public bar: string = ""; - } - - function fx2() { - let foo: Foo | null = null; - [1].forEach((item) => { - foo = new Foo(); - }); - if (foo) { - foo.bar; - } - } - - // https://github.com/microsoft/TypeScript/issues/57880 - - const call = (f: () => void) => f(); - - const fx3 = () => { - let a: undefined | number = undefined; - call(() => { a = 1; }); - if (a !== undefined) { - a.toString(); - } - }; - - // https://github.com/microsoft/TypeScript/issues/58291 - - async function execute(onError: (_err: Error | undefined) => void) { - onError(new Error("a")); - } - - async function run() { - let result: boolean = true; - await execute(() => { - result = false; - }); - if (result === false) { - console.log("error"); - } - return result; - } - \ No newline at end of file diff --git a/tests/baselines/reference/deferredCallbacks.js b/tests/baselines/reference/deferredCallbacks.js deleted file mode 100644 index da1accd10bbd5..0000000000000 --- a/tests/baselines/reference/deferredCallbacks.js +++ /dev/null @@ -1,464 +0,0 @@ -//// [tests/cases/compiler/deferredCallbacks.ts] //// - -//// [deferredCallbacks.ts] -declare function immediate(cb: () => void): void; -declare function deferred1(deferred cb: () => void): void; -declare function deferred2(/** @deferred */ cb: () => void): void; -declare function deferred3(/** @deferred */ deferred cb: () => void): void; - -function f01() { - let x: string | number = "OK"; - immediate(() => { - x = 42; - }); - x; // string | number -} - -function f02() { - let x: string | number = "OK"; - deferred1(() => { - x = 42; - }); - x; // string -} - -function f03() { - let x: string | number = "OK"; - deferred2(() => { - x = 42; - }); - x; // string -} - -function f04() { - let x: string | number = "OK"; - deferred3(() => { - x = 42; - }); - x; // string -} - -// Parameter is considered deferred if one or more overloads defer that parameter - -declare function overloaded(cb: (x: T) => T): void; -declare function overloaded(cb: (x: T, y: T) => T): void; -declare function overloaded(deferred cb: (...args: any) => any): void; - -function f05() { - let x: string | number = "OK"; - overloaded(() => { - x = 42; - }); - x.length; -} - -// deferred is permitted on a rest parameter - -declare function invokeImmediate(...args: ((...args: any) => any)[]): void; -declare function invokeDeferred(deferred ...args: ((...args: any) => any)[]): void; - -function f06() { - let a = []; - a.push("abc"); - a; // string[] - invokeImmediate( - () => { - a; // string[] - a.push(42); - a; // (string | number)[] - }, - () => { - a; // string[] - a.push(true); - a; // (string | boolean)[] - } - ); - a; // (string | number | boolean)[] -} - -function f07() { - let a = []; - a.push("abc"); - a; // string[] - invokeDeferred( - () => { - a; // string[] - a.push(42); - a; // (string | number)[] - }, - () => { - a; // string[] - a.push(true); - a; // (string | boolean)[] - } - ); - a; // string[] -} - -// deferred modifier must precede public/private/protected/readonly - -class CC { - constructor(deferred public readonly x: () => void) {} -} - -// deferred requires parameter to have type that permits functions - -declare function f10(deferred f: () => void): void; -declare function f11(deferred f: Function): void; -declare function f12(deferred f: any): void; -declare function f13(deferred f: object): void; -declare function f14(deferred f: {}): void; -declare function f15(deferred f: unknown): void; -declare function f16(deferred f: T): void; -declare function f17 any>(deferred f: T): void; -declare function f18 void)>(deferred f: T): void; - -declare function f20(deferred ...funcs: Function[]): void; -declare function f21 any)[]>(deferred ...funcs: T): void; -declare function f22 void))[]>(deferred ...funcs: T): void; -declare function f23 void)[]>(deferred ...funcs: T): void; -declare function f24 void)[]>(deferred ...funcs: T | string[]): void; - -declare function f30(deferred f: { foo(): void }): void; -declare function f31(deferred f: number): void; -declare function f32(deferred ...funcs: number[]): void; - -type T10 = (deferred f: () => void) => void; -type T11 = (deferred f: { (): void }) => void; -type T12 = (deferred f: Function) => void; -type T13 = (deferred f: any) => void; - -type T20 = (deferred f: { foo(): void }) => void; -type T21 = (deferred f: number) => void; -type T22 = (deferred ...funcs: number[]) => void; -type T23 = { deferred x: () => void }; - -// deferred modifier is not captured in argument list tuples - -declare function doStuff(deferred f: () => void): void; - -declare function recreate(f: (...args: A) => R): (...args: A) => R; -declare function recreateDeferred1(f: (deferred ...args: A) => R): (...args: A) => R; -declare function recreateDeferred2(f: (...args: A) => R): (deferred ...args: A) => R; - -function ff1() { - let x: string | number; - x = 123; - doStuff(() => { - x = "hi"; - }); - x; // number -} - -function ff2() { - let y: string | number; - y = 123; - recreate(doStuff)(() => { - y = "hi"; - }); - y; // string | number -} - -function ff3() { - let z: string | number; - z = 123; - recreateDeferred1(doStuff)(() => { - z = "hi"; - }); - z; // string | number -} - -function ff4() { - let z: string | number; - z = 123; - recreateDeferred2(doStuff)(() => { - z = "hi"; - }); - z; // number -} - -// https://github.com/microsoft/TypeScript/issues/11498 - -declare function mystery(cb: () => void): void; - -function fx1() { - let x: string | number = "OK"; - x; // string - mystery(() => { - x = 10; - }); - x; // string | number - if (x === 10) {} -} - -// https://github.com/microsoft/TypeScript/issues/15380 - -class Foo { - public bar: string = ""; -} - -function fx2() { - let foo: Foo | null = null; - [1].forEach((item) => { - foo = new Foo(); - }); - if (foo) { - foo.bar; - } -} - -// https://github.com/microsoft/TypeScript/issues/57880 - -const call = (f: () => void) => f(); - -const fx3 = () => { - let a: undefined | number = undefined; - call(() => { a = 1; }); - if (a !== undefined) { - a.toString(); - } -}; - -// https://github.com/microsoft/TypeScript/issues/58291 - -async function execute(onError: (_err: Error | undefined) => void) { - onError(new Error("a")); -} - -async function run() { - let result: boolean = true; - await execute(() => { - result = false; - }); - if (result === false) { - console.log("error"); - } - return result; -} - - -//// [deferredCallbacks.js] -"use strict"; -function f01() { - let x = "OK"; - immediate(() => { - x = 42; - }); - x; // string | number -} -function f02() { - let x = "OK"; - deferred1(() => { - x = 42; - }); - x; // string -} -function f03() { - let x = "OK"; - deferred2(() => { - x = 42; - }); - x; // string -} -function f04() { - let x = "OK"; - deferred3(() => { - x = 42; - }); - x; // string -} -function f05() { - let x = "OK"; - overloaded(() => { - x = 42; - }); - x.length; -} -function f06() { - let a = []; - a.push("abc"); - a; // string[] - invokeImmediate(() => { - a; // string[] - a.push(42); - a; // (string | number)[] - }, () => { - a; // string[] - a.push(true); - a; // (string | boolean)[] - }); - a; // (string | number | boolean)[] -} -function f07() { - let a = []; - a.push("abc"); - a; // string[] - invokeDeferred(() => { - a; // string[] - a.push(42); - a; // (string | number)[] - }, () => { - a; // string[] - a.push(true); - a; // (string | boolean)[] - }); - a; // string[] -} -// deferred modifier must precede public/private/protected/readonly -class CC { - x; - constructor(x) { - this.x = x; - } -} -function ff1() { - let x; - x = 123; - doStuff(() => { - x = "hi"; - }); - x; // number -} -function ff2() { - let y; - y = 123; - recreate(doStuff)(() => { - y = "hi"; - }); - y; // string | number -} -function ff3() { - let z; - z = 123; - recreateDeferred1(doStuff)(() => { - z = "hi"; - }); - z; // string | number -} -function ff4() { - let z; - z = 123; - recreateDeferred2(doStuff)(() => { - z = "hi"; - }); - z; // number -} -function fx1() { - let x = "OK"; - x; // string - mystery(() => { - x = 10; - }); - x; // string | number - if (x === 10) { } -} -// https://github.com/microsoft/TypeScript/issues/15380 -class Foo { - bar = ""; -} -function fx2() { - let foo = null; - [1].forEach((item) => { - foo = new Foo(); - }); - if (foo) { - foo.bar; - } -} -// https://github.com/microsoft/TypeScript/issues/57880 -const call = (f) => f(); -const fx3 = () => { - let a = undefined; - call(() => { a = 1; }); - if (a !== undefined) { - a.toString(); - } -}; -// https://github.com/microsoft/TypeScript/issues/58291 -async function execute(onError) { - onError(new Error("a")); -} -async function run() { - let result = true; - await execute(() => { - result = false; - }); - if (result === false) { - console.log("error"); - } - return result; -} - - -//// [deferredCallbacks.d.ts] -declare function immediate(cb: () => void): void; -declare function deferred1(deferred cb: () => void): void; -declare function deferred2(/** @deferred */ cb: () => void): void; -declare function deferred3(/** @deferred */ deferred cb: () => void): void; -declare function f01(): void; -declare function f02(): void; -declare function f03(): void; -declare function f04(): void; -declare function overloaded(cb: (x: T) => T): void; -declare function overloaded(cb: (x: T, y: T) => T): void; -declare function overloaded(deferred cb: (...args: any) => any): void; -declare function f05(): void; -declare function invokeImmediate(...args: ((...args: any) => any)[]): void; -declare function invokeDeferred(deferred ...args: ((...args: any) => any)[]): void; -declare function f06(): void; -declare function f07(): void; -declare class CC { - deferred readonly x: () => void; - constructor(x: () => void); -} -declare function f10(deferred f: () => void): void; -declare function f11(deferred f: Function): void; -declare function f12(deferred f: any): void; -declare function f13(deferred f: object): void; -declare function f14(deferred f: {}): void; -declare function f15(deferred f: unknown): void; -declare function f16(deferred f: T): void; -declare function f17 any>(deferred f: T): void; -declare function f18 void)>(deferred f: T): void; -declare function f20(deferred ...funcs: Function[]): void; -declare function f21 any)[]>(deferred ...funcs: T): void; -declare function f22 void))[]>(deferred ...funcs: T): void; -declare function f23 void)[]>(deferred ...funcs: T): void; -declare function f24 void)[]>(deferred ...funcs: T | string[]): void; -declare function f30(deferred f: { - foo(): void; -}): void; -declare function f31(deferred f: number): void; -declare function f32(deferred ...funcs: number[]): void; -type T10 = (deferred f: () => void) => void; -type T11 = (deferred f: { - (): void; -}) => void; -type T12 = (deferred f: Function) => void; -type T13 = (deferred f: any) => void; -type T20 = (deferred f: { - foo(): void; -}) => void; -type T21 = (deferred f: number) => void; -type T22 = (deferred ...funcs: number[]) => void; -type T23 = { - deferred x: () => void; -}; -declare function doStuff(deferred f: () => void): void; -declare function recreate(f: (...args: A) => R): (...args: A) => R; -declare function recreateDeferred1(f: (deferred ...args: A) => R): (...args: A) => R; -declare function recreateDeferred2(f: (...args: A) => R): (deferred ...args: A) => R; -declare function ff1(): void; -declare function ff2(): void; -declare function ff3(): void; -declare function ff4(): void; -declare function mystery(cb: () => void): void; -declare function fx1(): void; -declare class Foo { - bar: string; -} -declare function fx2(): void; -declare const call: (f: () => void) => void; -declare const fx3: () => void; -declare function execute(onError: (_err: Error | undefined) => void): Promise; -declare function run(): Promise; diff --git a/tests/baselines/reference/deferredCallbacks.symbols b/tests/baselines/reference/deferredCallbacks.symbols deleted file mode 100644 index 1d8162916b552..0000000000000 --- a/tests/baselines/reference/deferredCallbacks.symbols +++ /dev/null @@ -1,627 +0,0 @@ -//// [tests/cases/compiler/deferredCallbacks.ts] //// - -=== deferredCallbacks.ts === -declare function immediate(cb: () => void): void; ->immediate : Symbol(immediate, Decl(deferredCallbacks.ts, 0, 0)) ->cb : Symbol(cb, Decl(deferredCallbacks.ts, 0, 27)) - -declare function deferred1(deferred cb: () => void): void; ->deferred1 : Symbol(deferred1, Decl(deferredCallbacks.ts, 0, 49)) ->cb : Symbol(cb, Decl(deferredCallbacks.ts, 1, 27)) - -declare function deferred2(/** @deferred */ cb: () => void): void; ->deferred2 : Symbol(deferred2, Decl(deferredCallbacks.ts, 1, 58)) ->cb : Symbol(cb, Decl(deferredCallbacks.ts, 2, 27)) - -declare function deferred3(/** @deferred */ deferred cb: () => void): void; ->deferred3 : Symbol(deferred3, Decl(deferredCallbacks.ts, 2, 66)) ->cb : Symbol(cb, Decl(deferredCallbacks.ts, 3, 27)) - -function f01() { ->f01 : Symbol(f01, Decl(deferredCallbacks.ts, 3, 75)) - - let x: string | number = "OK"; ->x : Symbol(x, Decl(deferredCallbacks.ts, 6, 7)) - - immediate(() => { ->immediate : Symbol(immediate, Decl(deferredCallbacks.ts, 0, 0)) - - x = 42; ->x : Symbol(x, Decl(deferredCallbacks.ts, 6, 7)) - - }); - x; // string | number ->x : Symbol(x, Decl(deferredCallbacks.ts, 6, 7)) -} - -function f02() { ->f02 : Symbol(f02, Decl(deferredCallbacks.ts, 11, 1)) - - let x: string | number = "OK"; ->x : Symbol(x, Decl(deferredCallbacks.ts, 14, 7)) - - deferred1(() => { ->deferred1 : Symbol(deferred1, Decl(deferredCallbacks.ts, 0, 49)) - - x = 42; ->x : Symbol(x, Decl(deferredCallbacks.ts, 14, 7)) - - }); - x; // string ->x : Symbol(x, Decl(deferredCallbacks.ts, 14, 7)) -} - -function f03() { ->f03 : Symbol(f03, Decl(deferredCallbacks.ts, 19, 1)) - - let x: string | number = "OK"; ->x : Symbol(x, Decl(deferredCallbacks.ts, 22, 7)) - - deferred2(() => { ->deferred2 : Symbol(deferred2, Decl(deferredCallbacks.ts, 1, 58)) - - x = 42; ->x : Symbol(x, Decl(deferredCallbacks.ts, 22, 7)) - - }); - x; // string ->x : Symbol(x, Decl(deferredCallbacks.ts, 22, 7)) -} - -function f04() { ->f04 : Symbol(f04, Decl(deferredCallbacks.ts, 27, 1)) - - let x: string | number = "OK"; ->x : Symbol(x, Decl(deferredCallbacks.ts, 30, 7)) - - deferred3(() => { ->deferred3 : Symbol(deferred3, Decl(deferredCallbacks.ts, 2, 66)) - - x = 42; ->x : Symbol(x, Decl(deferredCallbacks.ts, 30, 7)) - - }); - x; // string ->x : Symbol(x, Decl(deferredCallbacks.ts, 30, 7)) -} - -// Parameter is considered deferred if one or more overloads defer that parameter - -declare function overloaded(cb: (x: T) => T): void; ->overloaded : Symbol(overloaded, Decl(deferredCallbacks.ts, 35, 1), Decl(deferredCallbacks.ts, 39, 54), Decl(deferredCallbacks.ts, 40, 60)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 39, 28)) ->cb : Symbol(cb, Decl(deferredCallbacks.ts, 39, 31)) ->x : Symbol(x, Decl(deferredCallbacks.ts, 39, 36)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 39, 28)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 39, 28)) - -declare function overloaded(cb: (x: T, y: T) => T): void; ->overloaded : Symbol(overloaded, Decl(deferredCallbacks.ts, 35, 1), Decl(deferredCallbacks.ts, 39, 54), Decl(deferredCallbacks.ts, 40, 60)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 40, 28)) ->cb : Symbol(cb, Decl(deferredCallbacks.ts, 40, 31)) ->x : Symbol(x, Decl(deferredCallbacks.ts, 40, 36)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 40, 28)) ->y : Symbol(y, Decl(deferredCallbacks.ts, 40, 41)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 40, 28)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 40, 28)) - -declare function overloaded(deferred cb: (...args: any) => any): void; ->overloaded : Symbol(overloaded, Decl(deferredCallbacks.ts, 35, 1), Decl(deferredCallbacks.ts, 39, 54), Decl(deferredCallbacks.ts, 40, 60)) ->cb : Symbol(cb, Decl(deferredCallbacks.ts, 41, 28)) ->args : Symbol(args, Decl(deferredCallbacks.ts, 41, 42)) - -function f05() { ->f05 : Symbol(f05, Decl(deferredCallbacks.ts, 41, 70)) - - let x: string | number = "OK"; ->x : Symbol(x, Decl(deferredCallbacks.ts, 44, 7)) - - overloaded(() => { ->overloaded : Symbol(overloaded, Decl(deferredCallbacks.ts, 35, 1), Decl(deferredCallbacks.ts, 39, 54), Decl(deferredCallbacks.ts, 40, 60)) - - x = 42; ->x : Symbol(x, Decl(deferredCallbacks.ts, 44, 7)) - - }); - x.length; ->x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) ->x : Symbol(x, Decl(deferredCallbacks.ts, 44, 7)) ->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) -} - -// deferred is permitted on a rest parameter - -declare function invokeImmediate(...args: ((...args: any) => any)[]): void; ->invokeImmediate : Symbol(invokeImmediate, Decl(deferredCallbacks.ts, 49, 1)) ->args : Symbol(args, Decl(deferredCallbacks.ts, 53, 33)) ->args : Symbol(args, Decl(deferredCallbacks.ts, 53, 44)) - -declare function invokeDeferred(deferred ...args: ((...args: any) => any)[]): void; ->invokeDeferred : Symbol(invokeDeferred, Decl(deferredCallbacks.ts, 53, 75)) ->args : Symbol(args, Decl(deferredCallbacks.ts, 54, 32)) ->args : Symbol(args, Decl(deferredCallbacks.ts, 54, 52)) - -function f06() { ->f06 : Symbol(f06, Decl(deferredCallbacks.ts, 54, 83)) - - let a = []; ->a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) - - a.push("abc"); ->a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) ->push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) - - a; // string[] ->a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) - - invokeImmediate( ->invokeImmediate : Symbol(invokeImmediate, Decl(deferredCallbacks.ts, 49, 1)) - - () => { - a; // string[] ->a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) - - a.push(42); ->a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) ->push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) - - a; // (string | number)[] ->a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) - - }, - () => { - a; // string[] ->a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) - - a.push(true); ->a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) ->push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) - - a; // (string | boolean)[] ->a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) - } - ); - a; // (string | number | boolean)[] ->a : Symbol(a, Decl(deferredCallbacks.ts, 57, 7)) -} - -function f07() { ->f07 : Symbol(f07, Decl(deferredCallbacks.ts, 73, 1)) - - let a = []; ->a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) - - a.push("abc"); ->a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) ->push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) - - a; // string[] ->a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) - - invokeDeferred( ->invokeDeferred : Symbol(invokeDeferred, Decl(deferredCallbacks.ts, 53, 75)) - - () => { - a; // string[] ->a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) - - a.push(42); ->a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) ->push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) - - a; // (string | number)[] ->a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) - - }, - () => { - a; // string[] ->a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) - - a.push(true); ->a.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) ->push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) - - a; // (string | boolean)[] ->a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) - } - ); - a; // string[] ->a : Symbol(a, Decl(deferredCallbacks.ts, 76, 7)) -} - -// deferred modifier must precede public/private/protected/readonly - -class CC { ->CC : Symbol(CC, Decl(deferredCallbacks.ts, 92, 1)) - - constructor(deferred public readonly x: () => void) {} ->x : Symbol(CC.x, Decl(deferredCallbacks.ts, 97, 16)) -} - -// deferred requires parameter to have type that permits functions - -declare function f10(deferred f: () => void): void; ->f10 : Symbol(f10, Decl(deferredCallbacks.ts, 98, 1)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 102, 21)) - -declare function f11(deferred f: Function): void; ->f11 : Symbol(f11, Decl(deferredCallbacks.ts, 102, 51)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 103, 21)) ->Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) - -declare function f12(deferred f: any): void; ->f12 : Symbol(f12, Decl(deferredCallbacks.ts, 103, 49)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 104, 21)) - -declare function f13(deferred f: object): void; ->f13 : Symbol(f13, Decl(deferredCallbacks.ts, 104, 44)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 105, 21)) - -declare function f14(deferred f: {}): void; ->f14 : Symbol(f14, Decl(deferredCallbacks.ts, 105, 47)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 106, 21)) - -declare function f15(deferred f: unknown): void; ->f15 : Symbol(f15, Decl(deferredCallbacks.ts, 106, 43)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 107, 21)) - -declare function f16(deferred f: T): void; ->f16 : Symbol(f16, Decl(deferredCallbacks.ts, 107, 48)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 108, 21)) ->Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 108, 41)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 108, 21)) - -declare function f17 any>(deferred f: T): void; ->f17 : Symbol(f17, Decl(deferredCallbacks.ts, 108, 62)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 109, 21)) ->args : Symbol(args, Decl(deferredCallbacks.ts, 109, 32)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 109, 54)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 109, 21)) - -declare function f18 void)>(deferred f: T): void; ->f18 : Symbol(f18, Decl(deferredCallbacks.ts, 109, 75)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 110, 21)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 110, 54)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 110, 21)) - -declare function f20(deferred ...funcs: Function[]): void; ->f20 : Symbol(f20, Decl(deferredCallbacks.ts, 110, 75)) ->funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 112, 21)) ->Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) - -declare function f21 any)[]>(deferred ...funcs: T): void; ->f21 : Symbol(f21, Decl(deferredCallbacks.ts, 112, 58)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 113, 21)) ->args : Symbol(args, Decl(deferredCallbacks.ts, 113, 33)) ->funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 113, 58)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 113, 21)) - -declare function f22 void))[]>(deferred ...funcs: T): void; ->f22 : Symbol(f22, Decl(deferredCallbacks.ts, 113, 86)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 114, 21)) ->funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 114, 58)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 114, 21)) - -declare function f23 void)[]>(deferred ...funcs: T): void; ->f23 : Symbol(f23, Decl(deferredCallbacks.ts, 114, 86)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 115, 21)) ->funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 115, 58)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 115, 21)) - -declare function f24 void)[]>(deferred ...funcs: T | string[]): void; ->f24 : Symbol(f24, Decl(deferredCallbacks.ts, 115, 86)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 116, 21)) ->funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 116, 47)) ->T : Symbol(T, Decl(deferredCallbacks.ts, 116, 21)) - -declare function f30(deferred f: { foo(): void }): void; ->f30 : Symbol(f30, Decl(deferredCallbacks.ts, 116, 86)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 118, 21)) ->foo : Symbol(foo, Decl(deferredCallbacks.ts, 118, 34)) - -declare function f31(deferred f: number): void; ->f31 : Symbol(f31, Decl(deferredCallbacks.ts, 118, 56)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 119, 21)) - -declare function f32(deferred ...funcs: number[]): void; ->f32 : Symbol(f32, Decl(deferredCallbacks.ts, 119, 47)) ->funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 120, 21)) - -type T10 = (deferred f: () => void) => void; ->T10 : Symbol(T10, Decl(deferredCallbacks.ts, 120, 56)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 122, 12)) - -type T11 = (deferred f: { (): void }) => void; ->T11 : Symbol(T11, Decl(deferredCallbacks.ts, 122, 44)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 123, 12)) - -type T12 = (deferred f: Function) => void; ->T12 : Symbol(T12, Decl(deferredCallbacks.ts, 123, 46)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 124, 12)) ->Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) - -type T13 = (deferred f: any) => void; ->T13 : Symbol(T13, Decl(deferredCallbacks.ts, 124, 42)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 125, 12)) - -type T20 = (deferred f: { foo(): void }) => void; ->T20 : Symbol(T20, Decl(deferredCallbacks.ts, 125, 37)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 127, 12)) ->foo : Symbol(foo, Decl(deferredCallbacks.ts, 127, 25)) - -type T21 = (deferred f: number) => void; ->T21 : Symbol(T21, Decl(deferredCallbacks.ts, 127, 49)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 128, 12)) - -type T22 = (deferred ...funcs: number[]) => void; ->T22 : Symbol(T22, Decl(deferredCallbacks.ts, 128, 40)) ->funcs : Symbol(funcs, Decl(deferredCallbacks.ts, 129, 12)) - -type T23 = { deferred x: () => void }; ->T23 : Symbol(T23, Decl(deferredCallbacks.ts, 129, 49)) ->x : Symbol(x, Decl(deferredCallbacks.ts, 130, 12)) - -// deferred modifier is not captured in argument list tuples - -declare function doStuff(deferred f: () => void): void; ->doStuff : Symbol(doStuff, Decl(deferredCallbacks.ts, 130, 38)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 134, 25)) - -declare function recreate(f: (...args: A) => R): (...args: A) => R; ->recreate : Symbol(recreate, Decl(deferredCallbacks.ts, 134, 55)) ->A : Symbol(A, Decl(deferredCallbacks.ts, 136, 26)) ->R : Symbol(R, Decl(deferredCallbacks.ts, 136, 46)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 136, 50)) ->args : Symbol(args, Decl(deferredCallbacks.ts, 136, 54)) ->A : Symbol(A, Decl(deferredCallbacks.ts, 136, 26)) ->R : Symbol(R, Decl(deferredCallbacks.ts, 136, 46)) ->args : Symbol(args, Decl(deferredCallbacks.ts, 136, 74)) ->A : Symbol(A, Decl(deferredCallbacks.ts, 136, 26)) ->R : Symbol(R, Decl(deferredCallbacks.ts, 136, 46)) - -declare function recreateDeferred1(f: (deferred ...args: A) => R): (...args: A) => R; ->recreateDeferred1 : Symbol(recreateDeferred1, Decl(deferredCallbacks.ts, 136, 91)) ->A : Symbol(A, Decl(deferredCallbacks.ts, 137, 35)) ->R : Symbol(R, Decl(deferredCallbacks.ts, 137, 55)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 137, 59)) ->args : Symbol(args, Decl(deferredCallbacks.ts, 137, 63)) ->A : Symbol(A, Decl(deferredCallbacks.ts, 137, 35)) ->R : Symbol(R, Decl(deferredCallbacks.ts, 137, 55)) ->args : Symbol(args, Decl(deferredCallbacks.ts, 137, 92)) ->A : Symbol(A, Decl(deferredCallbacks.ts, 137, 35)) ->R : Symbol(R, Decl(deferredCallbacks.ts, 137, 55)) - -declare function recreateDeferred2(f: (...args: A) => R): (deferred ...args: A) => R; ->recreateDeferred2 : Symbol(recreateDeferred2, Decl(deferredCallbacks.ts, 137, 109)) ->A : Symbol(A, Decl(deferredCallbacks.ts, 138, 35)) ->R : Symbol(R, Decl(deferredCallbacks.ts, 138, 55)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 138, 59)) ->args : Symbol(args, Decl(deferredCallbacks.ts, 138, 63)) ->A : Symbol(A, Decl(deferredCallbacks.ts, 138, 35)) ->R : Symbol(R, Decl(deferredCallbacks.ts, 138, 55)) ->args : Symbol(args, Decl(deferredCallbacks.ts, 138, 83)) ->A : Symbol(A, Decl(deferredCallbacks.ts, 138, 35)) ->R : Symbol(R, Decl(deferredCallbacks.ts, 138, 55)) - -function ff1() { ->ff1 : Symbol(ff1, Decl(deferredCallbacks.ts, 138, 109)) - - let x: string | number; ->x : Symbol(x, Decl(deferredCallbacks.ts, 141, 7)) - - x = 123; ->x : Symbol(x, Decl(deferredCallbacks.ts, 141, 7)) - - doStuff(() => { ->doStuff : Symbol(doStuff, Decl(deferredCallbacks.ts, 130, 38)) - - x = "hi"; ->x : Symbol(x, Decl(deferredCallbacks.ts, 141, 7)) - - }); - x; // number ->x : Symbol(x, Decl(deferredCallbacks.ts, 141, 7)) -} - -function ff2() { ->ff2 : Symbol(ff2, Decl(deferredCallbacks.ts, 147, 1)) - - let y: string | number; ->y : Symbol(y, Decl(deferredCallbacks.ts, 150, 7)) - - y = 123; ->y : Symbol(y, Decl(deferredCallbacks.ts, 150, 7)) - - recreate(doStuff)(() => { ->recreate : Symbol(recreate, Decl(deferredCallbacks.ts, 134, 55)) ->doStuff : Symbol(doStuff, Decl(deferredCallbacks.ts, 130, 38)) - - y = "hi"; ->y : Symbol(y, Decl(deferredCallbacks.ts, 150, 7)) - - }); - y; // string | number ->y : Symbol(y, Decl(deferredCallbacks.ts, 150, 7)) -} - -function ff3() { ->ff3 : Symbol(ff3, Decl(deferredCallbacks.ts, 156, 1)) - - let z: string | number; ->z : Symbol(z, Decl(deferredCallbacks.ts, 159, 7)) - - z = 123; ->z : Symbol(z, Decl(deferredCallbacks.ts, 159, 7)) - - recreateDeferred1(doStuff)(() => { ->recreateDeferred1 : Symbol(recreateDeferred1, Decl(deferredCallbacks.ts, 136, 91)) ->doStuff : Symbol(doStuff, Decl(deferredCallbacks.ts, 130, 38)) - - z = "hi"; ->z : Symbol(z, Decl(deferredCallbacks.ts, 159, 7)) - - }); - z; // string | number ->z : Symbol(z, Decl(deferredCallbacks.ts, 159, 7)) -} - -function ff4() { ->ff4 : Symbol(ff4, Decl(deferredCallbacks.ts, 165, 1)) - - let z: string | number; ->z : Symbol(z, Decl(deferredCallbacks.ts, 168, 7)) - - z = 123; ->z : Symbol(z, Decl(deferredCallbacks.ts, 168, 7)) - - recreateDeferred2(doStuff)(() => { ->recreateDeferred2 : Symbol(recreateDeferred2, Decl(deferredCallbacks.ts, 137, 109)) ->doStuff : Symbol(doStuff, Decl(deferredCallbacks.ts, 130, 38)) - - z = "hi"; ->z : Symbol(z, Decl(deferredCallbacks.ts, 168, 7)) - - }); - z; // number ->z : Symbol(z, Decl(deferredCallbacks.ts, 168, 7)) -} - -// https://github.com/microsoft/TypeScript/issues/11498 - -declare function mystery(cb: () => void): void; ->mystery : Symbol(mystery, Decl(deferredCallbacks.ts, 174, 1)) ->cb : Symbol(cb, Decl(deferredCallbacks.ts, 178, 25)) - -function fx1() { ->fx1 : Symbol(fx1, Decl(deferredCallbacks.ts, 178, 47)) - - let x: string | number = "OK"; ->x : Symbol(x, Decl(deferredCallbacks.ts, 181, 7)) - - x; // string ->x : Symbol(x, Decl(deferredCallbacks.ts, 181, 7)) - - mystery(() => { ->mystery : Symbol(mystery, Decl(deferredCallbacks.ts, 174, 1)) - - x = 10; ->x : Symbol(x, Decl(deferredCallbacks.ts, 181, 7)) - - }); - x; // string | number ->x : Symbol(x, Decl(deferredCallbacks.ts, 181, 7)) - - if (x === 10) {} ->x : Symbol(x, Decl(deferredCallbacks.ts, 181, 7)) -} - -// https://github.com/microsoft/TypeScript/issues/15380 - -class Foo { ->Foo : Symbol(Foo, Decl(deferredCallbacks.ts, 188, 1)) - - public bar: string = ""; ->bar : Symbol(Foo.bar, Decl(deferredCallbacks.ts, 192, 11)) -} - -function fx2() { ->fx2 : Symbol(fx2, Decl(deferredCallbacks.ts, 194, 1)) - - let foo: Foo | null = null; ->foo : Symbol(foo, Decl(deferredCallbacks.ts, 197, 5)) ->Foo : Symbol(Foo, Decl(deferredCallbacks.ts, 188, 1)) - - [1].forEach((item) => { ->[1].forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --)) ->forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --)) ->item : Symbol(item, Decl(deferredCallbacks.ts, 198, 15)) - - foo = new Foo(); ->foo : Symbol(foo, Decl(deferredCallbacks.ts, 197, 5)) ->Foo : Symbol(Foo, Decl(deferredCallbacks.ts, 188, 1)) - - }); - if (foo) { ->foo : Symbol(foo, Decl(deferredCallbacks.ts, 197, 5)) - - foo.bar; ->foo.bar : Symbol(Foo.bar, Decl(deferredCallbacks.ts, 192, 11)) ->foo : Symbol(foo, Decl(deferredCallbacks.ts, 197, 5)) ->bar : Symbol(Foo.bar, Decl(deferredCallbacks.ts, 192, 11)) - } -} - -// https://github.com/microsoft/TypeScript/issues/57880 - -const call = (f: () => void) => f(); ->call : Symbol(call, Decl(deferredCallbacks.ts, 208, 5)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 208, 14)) ->f : Symbol(f, Decl(deferredCallbacks.ts, 208, 14)) - -const fx3 = () => { ->fx3 : Symbol(fx3, Decl(deferredCallbacks.ts, 210, 5)) - - let a: undefined | number = undefined; ->a : Symbol(a, Decl(deferredCallbacks.ts, 211, 7)) ->undefined : Symbol(undefined) - - call(() => { a = 1; }); ->call : Symbol(call, Decl(deferredCallbacks.ts, 208, 5)) ->a : Symbol(a, Decl(deferredCallbacks.ts, 211, 7)) - - if (a !== undefined) { ->a : Symbol(a, Decl(deferredCallbacks.ts, 211, 7)) ->undefined : Symbol(undefined) - - a.toString(); ->a.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(deferredCallbacks.ts, 211, 7)) ->toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) - } -}; - -// https://github.com/microsoft/TypeScript/issues/58291 - -async function execute(onError: (_err: Error | undefined) => void) { ->execute : Symbol(execute, Decl(deferredCallbacks.ts, 216, 2)) ->onError : Symbol(onError, Decl(deferredCallbacks.ts, 220, 23)) ->_err : Symbol(_err, Decl(deferredCallbacks.ts, 220, 33)) ->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) - - onError(new Error("a")); ->onError : Symbol(onError, Decl(deferredCallbacks.ts, 220, 23)) ->Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) -} - -async function run() { ->run : Symbol(run, Decl(deferredCallbacks.ts, 222, 1)) - - let result: boolean = true; ->result : Symbol(result, Decl(deferredCallbacks.ts, 225, 7)) - - await execute(() => { ->execute : Symbol(execute, Decl(deferredCallbacks.ts, 216, 2)) - - result = false; ->result : Symbol(result, Decl(deferredCallbacks.ts, 225, 7)) - - }); - if (result === false) { ->result : Symbol(result, Decl(deferredCallbacks.ts, 225, 7)) - - console.log("error"); ->console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) ->console : Symbol(console, Decl(lib.dom.d.ts, --, --)) ->log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) - } - return result; ->result : Symbol(result, Decl(deferredCallbacks.ts, 225, 7)) -} - diff --git a/tests/baselines/reference/deferredCallbacks.types b/tests/baselines/reference/deferredCallbacks.types deleted file mode 100644 index a0cd92c7b6c22..0000000000000 --- a/tests/baselines/reference/deferredCallbacks.types +++ /dev/null @@ -1,1035 +0,0 @@ -//// [tests/cases/compiler/deferredCallbacks.ts] //// - -=== deferredCallbacks.ts === -declare function immediate(cb: () => void): void; ->immediate : (cb: () => void) => void -> : ^ ^^ ^^^^^ ->cb : () => void -> : ^^^^^^ - -declare function deferred1(deferred cb: () => void): void; ->deferred1 : (cb: () => void) => void -> : ^ ^^ ^^^^^ ->cb : () => void -> : ^^^^^^ - -declare function deferred2(/** @deferred */ cb: () => void): void; ->deferred2 : (cb: () => void) => void -> : ^ ^^ ^^^^^ ->cb : () => void -> : ^^^^^^ - -declare function deferred3(/** @deferred */ deferred cb: () => void): void; ->deferred3 : (cb: () => void) => void -> : ^ ^^ ^^^^^ ->cb : () => void -> : ^^^^^^ - -function f01() { ->f01 : () => void -> : ^^^^^^^^^^ - - let x: string | number = "OK"; ->x : string | number -> : ^^^^^^^^^^^^^^^ ->"OK" : "OK" -> : ^^^^ - - immediate(() => { ->immediate(() => { x = 42; }) : void -> : ^^^^ ->immediate : (cb: () => void) => void -> : ^ ^^ ^^^^^ ->() => { x = 42; } : () => void -> : ^^^^^^^^^^ - - x = 42; ->x = 42 : 42 -> : ^^ ->x : string | number -> : ^^^^^^^^^^^^^^^ ->42 : 42 -> : ^^ - - }); - x; // string | number ->x : string | number -> : ^^^^^^^^^^^^^^^ -} - -function f02() { ->f02 : () => void -> : ^^^^^^^^^^ - - let x: string | number = "OK"; ->x : string | number -> : ^^^^^^^^^^^^^^^ ->"OK" : "OK" -> : ^^^^ - - deferred1(() => { ->deferred1(() => { x = 42; }) : void -> : ^^^^ ->deferred1 : (cb: () => void) => void -> : ^ ^^ ^^^^^ ->() => { x = 42; } : () => void -> : ^^^^^^^^^^ - - x = 42; ->x = 42 : 42 -> : ^^ ->x : string | number -> : ^^^^^^^^^^^^^^^ ->42 : 42 -> : ^^ - - }); - x; // string ->x : string -> : ^^^^^^ -} - -function f03() { ->f03 : () => void -> : ^^^^^^^^^^ - - let x: string | number = "OK"; ->x : string | number -> : ^^^^^^^^^^^^^^^ ->"OK" : "OK" -> : ^^^^ - - deferred2(() => { ->deferred2(() => { x = 42; }) : void -> : ^^^^ ->deferred2 : (cb: () => void) => void -> : ^ ^^ ^^^^^ ->() => { x = 42; } : () => void -> : ^^^^^^^^^^ - - x = 42; ->x = 42 : 42 -> : ^^ ->x : string | number -> : ^^^^^^^^^^^^^^^ ->42 : 42 -> : ^^ - - }); - x; // string ->x : string -> : ^^^^^^ -} - -function f04() { ->f04 : () => void -> : ^^^^^^^^^^ - - let x: string | number = "OK"; ->x : string | number -> : ^^^^^^^^^^^^^^^ ->"OK" : "OK" -> : ^^^^ - - deferred3(() => { ->deferred3(() => { x = 42; }) : void -> : ^^^^ ->deferred3 : (cb: () => void) => void -> : ^ ^^ ^^^^^ ->() => { x = 42; } : () => void -> : ^^^^^^^^^^ - - x = 42; ->x = 42 : 42 -> : ^^ ->x : string | number -> : ^^^^^^^^^^^^^^^ ->42 : 42 -> : ^^ - - }); - x; // string ->x : string -> : ^^^^^^ -} - -// Parameter is considered deferred if one or more overloads defer that parameter - -declare function overloaded(cb: (x: T) => T): void; ->overloaded : { (cb: (x: T) => T): void; (cb: (x: T_1, y: T_1) => T_1): void; (cb: (...args: any) => any): void; } -> : ^^^ ^^ ^^ ^^^ ^^^^^^^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ ->cb : (x: T) => T -> : ^ ^^ ^^^^^ ->x : T -> : ^ - -declare function overloaded(cb: (x: T, y: T) => T): void; ->overloaded : { (cb: (x: T_1) => T_1): void; (cb: (x: T, y: T) => T): void; (cb: (...args: any) => any): void; } -> : ^^^^^^^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ ->cb : (x: T, y: T) => T -> : ^ ^^ ^^ ^^ ^^^^^ ->x : T -> : ^ ->y : T -> : ^ - -declare function overloaded(deferred cb: (...args: any) => any): void; ->overloaded : { (cb: (x: T) => T): void; (cb: (x: T, y: T) => T): void; (cb: (...args: any) => any): void; } -> : ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ ->cb : (...args: any) => any -> : ^^^^ ^^ ^^^^^ ->args : any -> : ^^^ - -function f05() { ->f05 : () => void -> : ^^^^^^^^^^ - - let x: string | number = "OK"; ->x : string | number -> : ^^^^^^^^^^^^^^^ ->"OK" : "OK" -> : ^^^^ - - overloaded(() => { ->overloaded(() => { x = 42; }) : void -> : ^^^^ ->overloaded : { (cb: (x: T) => T): void; (cb: (x: T, y: T) => T): void; (cb: (...args: any) => any): void; } -> : ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ ->() => { x = 42; } : () => void -> : ^^^^^^^^^^ - - x = 42; ->x = 42 : 42 -> : ^^ ->x : string | number -> : ^^^^^^^^^^^^^^^ ->42 : 42 -> : ^^ - - }); - x.length; ->x.length : number -> : ^^^^^^ ->x : string -> : ^^^^^^ ->length : number -> : ^^^^^^ -} - -// deferred is permitted on a rest parameter - -declare function invokeImmediate(...args: ((...args: any) => any)[]): void; ->invokeImmediate : (...args: ((...args: any) => any)[]) => void -> : ^^^^ ^^ ^^^^^ ->args : ((...args: any) => any)[] -> : ^^^^^ ^^ ^^^^^ ^^^ ->args : any -> : ^^^ - -declare function invokeDeferred(deferred ...args: ((...args: any) => any)[]): void; ->invokeDeferred : (...args: ((...args: any) => any)[]) => void -> : ^^^^ ^^ ^^^^^ ->args : ((...args: any) => any)[] -> : ^^^^^ ^^ ^^^^^ ^^^ ->args : any -> : ^^^ - -function f06() { ->f06 : () => void -> : ^^^^^^^^^^ - - let a = []; ->a : any[] -> : ^^^^^ ->[] : never[] -> : ^^^^^^^ - - a.push("abc"); ->a.push("abc") : number -> : ^^^^^^ ->a.push : (...items: any[]) => number -> : ^^^^ ^^^^^^^^^^^^ ->a : any[] -> : ^^^^^ ->push : (...items: any[]) => number -> : ^^^^ ^^^^^^^^^^^^ ->"abc" : "abc" -> : ^^^^^ - - a; // string[] ->a : string[] -> : ^^^^^^^^ - - invokeImmediate( ->invokeImmediate( () => { a; // string[] a.push(42); a; // (string | number)[] }, () => { a; // string[] a.push(true); a; // (string | boolean)[] } ) : void -> : ^^^^ ->invokeImmediate : (...args: ((...args: any) => any)[]) => void -> : ^^^^ ^^ ^^^^^ - - () => { ->() => { a; // string[] a.push(42); a; // (string | number)[] } : () => void -> : ^^^^^^^^^^ - - a; // string[] ->a : string[] -> : ^^^^^^^^ - - a.push(42); ->a.push(42) : number -> : ^^^^^^ ->a.push : (...items: any[]) => number -> : ^^^^ ^^^^^^^^^^^^ ->a : any[] -> : ^^^^^ ->push : (...items: any[]) => number -> : ^^^^ ^^^^^^^^^^^^ ->42 : 42 -> : ^^ - - a; // (string | number)[] ->a : (string | number)[] -> : ^^^^^^^^^^^^^^^^^^^ - - }, - () => { ->() => { a; // string[] a.push(true); a; // (string | boolean)[] } : () => void -> : ^^^^^^^^^^ - - a; // string[] ->a : string[] -> : ^^^^^^^^ - - a.push(true); ->a.push(true) : number -> : ^^^^^^ ->a.push : (...items: any[]) => number -> : ^^^^ ^^^^^^^^^^^^ ->a : any[] -> : ^^^^^ ->push : (...items: any[]) => number -> : ^^^^ ^^^^^^^^^^^^ ->true : true -> : ^^^^ - - a; // (string | boolean)[] ->a : (string | boolean)[] -> : ^^^^^^^^^^^^^^^^^^^^ - } - ); - a; // (string | number | boolean)[] ->a : (string | number | boolean)[] -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -} - -function f07() { ->f07 : () => void -> : ^^^^^^^^^^ - - let a = []; ->a : any[] -> : ^^^^^ ->[] : never[] -> : ^^^^^^^ - - a.push("abc"); ->a.push("abc") : number -> : ^^^^^^ ->a.push : (...items: any[]) => number -> : ^^^^ ^^^^^^^^^^^^ ->a : any[] -> : ^^^^^ ->push : (...items: any[]) => number -> : ^^^^ ^^^^^^^^^^^^ ->"abc" : "abc" -> : ^^^^^ - - a; // string[] ->a : string[] -> : ^^^^^^^^ - - invokeDeferred( ->invokeDeferred( () => { a; // string[] a.push(42); a; // (string | number)[] }, () => { a; // string[] a.push(true); a; // (string | boolean)[] } ) : void -> : ^^^^ ->invokeDeferred : (...args: ((...args: any) => any)[]) => void -> : ^^^^ ^^ ^^^^^ - - () => { ->() => { a; // string[] a.push(42); a; // (string | number)[] } : () => void -> : ^^^^^^^^^^ - - a; // string[] ->a : string[] -> : ^^^^^^^^ - - a.push(42); ->a.push(42) : number -> : ^^^^^^ ->a.push : (...items: any[]) => number -> : ^^^^ ^^^^^^^^^^^^ ->a : any[] -> : ^^^^^ ->push : (...items: any[]) => number -> : ^^^^ ^^^^^^^^^^^^ ->42 : 42 -> : ^^ - - a; // (string | number)[] ->a : (string | number)[] -> : ^^^^^^^^^^^^^^^^^^^ - - }, - () => { ->() => { a; // string[] a.push(true); a; // (string | boolean)[] } : () => void -> : ^^^^^^^^^^ - - a; // string[] ->a : string[] -> : ^^^^^^^^ - - a.push(true); ->a.push(true) : number -> : ^^^^^^ ->a.push : (...items: any[]) => number -> : ^^^^ ^^^^^^^^^^^^ ->a : any[] -> : ^^^^^ ->push : (...items: any[]) => number -> : ^^^^ ^^^^^^^^^^^^ ->true : true -> : ^^^^ - - a; // (string | boolean)[] ->a : (string | boolean)[] -> : ^^^^^^^^^^^^^^^^^^^^ - } - ); - a; // string[] ->a : string[] -> : ^^^^^^^^ -} - -// deferred modifier must precede public/private/protected/readonly - -class CC { ->CC : CC -> : ^^ - - constructor(deferred public readonly x: () => void) {} ->x : () => void -> : ^^^^^^ -} - -// deferred requires parameter to have type that permits functions - -declare function f10(deferred f: () => void): void; ->f10 : (f: () => void) => void -> : ^ ^^ ^^^^^ ->f : () => void -> : ^^^^^^ - -declare function f11(deferred f: Function): void; ->f11 : (f: Function) => void -> : ^ ^^ ^^^^^ ->f : Function -> : ^^^^^^^^ - -declare function f12(deferred f: any): void; ->f12 : (f: any) => void -> : ^ ^^ ^^^^^ ->f : any -> : ^^^ - -declare function f13(deferred f: object): void; ->f13 : (f: object) => void -> : ^ ^^ ^^^^^ ->f : object -> : ^^^^^^ - -declare function f14(deferred f: {}): void; ->f14 : (f: {}) => void -> : ^ ^^ ^^^^^ ->f : {} -> : ^^ - -declare function f15(deferred f: unknown): void; ->f15 : (f: unknown) => void -> : ^ ^^ ^^^^^ ->f : unknown -> : ^^^^^^^ - -declare function f16(deferred f: T): void; ->f16 : (f: T) => void -> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ ->f : T -> : ^ - -declare function f17 any>(deferred f: T): void; ->f17 : any>(f: T) => void -> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ ->args : any -> : ^^^ ->f : T -> : ^ - -declare function f18 void)>(deferred f: T): void; ->f18 : void)>(f: T) => void -> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ ->f : T -> : ^ - -declare function f20(deferred ...funcs: Function[]): void; ->f20 : (...funcs: Function[]) => void -> : ^^^^ ^^ ^^^^^ ->funcs : Function[] -> : ^^^^^^^^^^ - -declare function f21 any)[]>(deferred ...funcs: T): void; ->f21 : any)[]>(...funcs: T) => void -> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ ->args : any -> : ^^^ ->funcs : T -> : ^ - -declare function f22 void))[]>(deferred ...funcs: T): void; ->f22 : void))[]>(...funcs: T) => void -> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ ->funcs : T -> : ^ - -declare function f23 void)[]>(deferred ...funcs: T): void; ->f23 : void)[]>(...funcs: T) => void -> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ ->funcs : T -> : ^ - -declare function f24 void)[]>(deferred ...funcs: T | string[]): void; ->f24 : void)[]>(...funcs: T | string[]) => void -> : ^ ^^^^^^^^^ ^^^^^ ^^ ^^^^^ ->funcs : string[] | T -> : ^^^^^^^^^^^^ - -declare function f30(deferred f: { foo(): void }): void; ->f30 : (f: { foo(): void; }) => void -> : ^ ^^ ^^^^^ ->f : { foo(): void; } -> : ^^^^^^^^^ ^^^ ->foo : () => void -> : ^^^^^^ - -declare function f31(deferred f: number): void; ->f31 : (f: number) => void -> : ^ ^^ ^^^^^ ->f : number -> : ^^^^^^ - -declare function f32(deferred ...funcs: number[]): void; ->f32 : (...funcs: number[]) => void -> : ^^^^ ^^ ^^^^^ ->funcs : number[] -> : ^^^^^^^^ - -type T10 = (deferred f: () => void) => void; ->T10 : T10 -> : ^^^ ->f : () => void -> : ^^^^^^ - -type T11 = (deferred f: { (): void }) => void; ->T11 : T11 -> : ^^^ ->f : () => void -> : ^^^^^^ - -type T12 = (deferred f: Function) => void; ->T12 : T12 -> : ^^^ ->f : Function -> : ^^^^^^^^ - -type T13 = (deferred f: any) => void; ->T13 : T13 -> : ^^^ ->f : any -> : ^^^ - -type T20 = (deferred f: { foo(): void }) => void; ->T20 : T20 -> : ^^^ ->f : { foo(): void; } -> : ^^^^^^^^^ ^^^ ->foo : () => void -> : ^^^^^^ - -type T21 = (deferred f: number) => void; ->T21 : T21 -> : ^^^ ->f : number -> : ^^^^^^ - -type T22 = (deferred ...funcs: number[]) => void; ->T22 : T22 -> : ^^^ ->funcs : number[] -> : ^^^^^^^^ - -type T23 = { deferred x: () => void }; ->T23 : T23 -> : ^^^ ->x : () => void -> : ^^^^^^ - -// deferred modifier is not captured in argument list tuples - -declare function doStuff(deferred f: () => void): void; ->doStuff : (f: () => void) => void -> : ^ ^^ ^^^^^ ->f : () => void -> : ^^^^^^ - -declare function recreate(f: (...args: A) => R): (...args: A) => R; ->recreate : (f: (...args: A) => R) => (...args: A) => R -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ->f : (...args: A) => R -> : ^^^^ ^^ ^^^^^ ->args : A -> : ^ ->args : A -> : ^ - -declare function recreateDeferred1(f: (deferred ...args: A) => R): (...args: A) => R; ->recreateDeferred1 : (f: (deferred ...args: A) => R) => (...args: A) => R -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ->f : (...args: A) => R -> : ^^^^ ^^ ^^^^^ ->args : A -> : ^ ->args : A -> : ^ - -declare function recreateDeferred2(f: (...args: A) => R): (deferred ...args: A) => R; ->recreateDeferred2 : (f: (...args: A) => R) => (deferred ...args: A) => R -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ->f : (...args: A) => R -> : ^^^^ ^^ ^^^^^ ->args : A -> : ^ ->args : A -> : ^ - -function ff1() { ->ff1 : () => void -> : ^^^^^^^^^^ - - let x: string | number; ->x : string | number -> : ^^^^^^^^^^^^^^^ - - x = 123; ->x = 123 : 123 -> : ^^^ ->x : string | number -> : ^^^^^^^^^^^^^^^ ->123 : 123 -> : ^^^ - - doStuff(() => { ->doStuff(() => { x = "hi"; }) : void -> : ^^^^ ->doStuff : (f: () => void) => void -> : ^ ^^ ^^^^^ ->() => { x = "hi"; } : () => void -> : ^^^^^^^^^^ - - x = "hi"; ->x = "hi" : "hi" -> : ^^^^ ->x : string | number -> : ^^^^^^^^^^^^^^^ ->"hi" : "hi" -> : ^^^^ - - }); - x; // number ->x : number -> : ^^^^^^ -} - -function ff2() { ->ff2 : () => void -> : ^^^^^^^^^^ - - let y: string | number; ->y : string | number -> : ^^^^^^^^^^^^^^^ - - y = 123; ->y = 123 : 123 -> : ^^^ ->y : string | number -> : ^^^^^^^^^^^^^^^ ->123 : 123 -> : ^^^ - - recreate(doStuff)(() => { ->recreate(doStuff)(() => { y = "hi"; }) : void -> : ^^^^ ->recreate(doStuff) : (f: () => void) => void -> : ^^^^^^^^^^ ^^^^^^^^^ ->recreate : (f: (...args: A) => R) => (...args: A) => R -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ->doStuff : (f: () => void) => void -> : ^ ^^ ^^^^^ ->() => { y = "hi"; } : () => void -> : ^^^^^^^^^^ - - y = "hi"; ->y = "hi" : "hi" -> : ^^^^ ->y : string | number -> : ^^^^^^^^^^^^^^^ ->"hi" : "hi" -> : ^^^^ - - }); - y; // string | number ->y : string | number -> : ^^^^^^^^^^^^^^^ -} - -function ff3() { ->ff3 : () => void -> : ^^^^^^^^^^ - - let z: string | number; ->z : string | number -> : ^^^^^^^^^^^^^^^ - - z = 123; ->z = 123 : 123 -> : ^^^ ->z : string | number -> : ^^^^^^^^^^^^^^^ ->123 : 123 -> : ^^^ - - recreateDeferred1(doStuff)(() => { ->recreateDeferred1(doStuff)(() => { z = "hi"; }) : void -> : ^^^^ ->recreateDeferred1(doStuff) : (f: () => void) => void -> : ^^^^^^^^^^ ^^^^^^^^^ ->recreateDeferred1 : (f: (deferred ...args: A) => R) => (...args: A) => R -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ->doStuff : (f: () => void) => void -> : ^ ^^ ^^^^^ ->() => { z = "hi"; } : () => void -> : ^^^^^^^^^^ - - z = "hi"; ->z = "hi" : "hi" -> : ^^^^ ->z : string | number -> : ^^^^^^^^^^^^^^^ ->"hi" : "hi" -> : ^^^^ - - }); - z; // string | number ->z : string | number -> : ^^^^^^^^^^^^^^^ -} - -function ff4() { ->ff4 : () => void -> : ^^^^^^^^^^ - - let z: string | number; ->z : string | number -> : ^^^^^^^^^^^^^^^ - - z = 123; ->z = 123 : 123 -> : ^^^ ->z : string | number -> : ^^^^^^^^^^^^^^^ ->123 : 123 -> : ^^^ - - recreateDeferred2(doStuff)(() => { ->recreateDeferred2(doStuff)(() => { z = "hi"; }) : void -> : ^^^^ ->recreateDeferred2(doStuff) : (f: () => void) => void -> : ^^^^^^^^^^ ^^^^^^^^^ ->recreateDeferred2 : (f: (...args: A) => R) => (deferred ...args: A) => R -> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ->doStuff : (f: () => void) => void -> : ^ ^^ ^^^^^ ->() => { z = "hi"; } : () => void -> : ^^^^^^^^^^ - - z = "hi"; ->z = "hi" : "hi" -> : ^^^^ ->z : string | number -> : ^^^^^^^^^^^^^^^ ->"hi" : "hi" -> : ^^^^ - - }); - z; // number ->z : number -> : ^^^^^^ -} - -// https://github.com/microsoft/TypeScript/issues/11498 - -declare function mystery(cb: () => void): void; ->mystery : (cb: () => void) => void -> : ^ ^^ ^^^^^ ->cb : () => void -> : ^^^^^^ - -function fx1() { ->fx1 : () => void -> : ^^^^^^^^^^ - - let x: string | number = "OK"; ->x : string | number -> : ^^^^^^^^^^^^^^^ ->"OK" : "OK" -> : ^^^^ - - x; // string ->x : string -> : ^^^^^^ - - mystery(() => { ->mystery(() => { x = 10; }) : void -> : ^^^^ ->mystery : (cb: () => void) => void -> : ^ ^^ ^^^^^ ->() => { x = 10; } : () => void -> : ^^^^^^^^^^ - - x = 10; ->x = 10 : 10 -> : ^^ ->x : string | number -> : ^^^^^^^^^^^^^^^ ->10 : 10 -> : ^^ - - }); - x; // string | number ->x : string | number -> : ^^^^^^^^^^^^^^^ - - if (x === 10) {} ->x === 10 : boolean -> : ^^^^^^^ ->x : string | number -> : ^^^^^^^^^^^^^^^ ->10 : 10 -> : ^^ -} - -// https://github.com/microsoft/TypeScript/issues/15380 - -class Foo { ->Foo : Foo -> : ^^^ - - public bar: string = ""; ->bar : string -> : ^^^^^^ ->"" : "" -> : ^^ -} - -function fx2() { ->fx2 : () => void -> : ^^^^^^^^^^ - - let foo: Foo | null = null; ->foo : Foo | null -> : ^^^^^^^^^^ - - [1].forEach((item) => { ->[1].forEach((item) => { foo = new Foo(); }) : void -> : ^^^^ ->[1].forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void -> : ^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ->[1] : number[] -> : ^^^^^^^^ ->1 : 1 -> : ^ ->forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void -> : ^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^ ->(item) => { foo = new Foo(); } : (item: number) => void -> : ^ ^^^^^^^^^^^^^^^^^ ->item : number -> : ^^^^^^ - - foo = new Foo(); ->foo = new Foo() : Foo -> : ^^^ ->foo : Foo | null -> : ^^^^^^^^^^ ->new Foo() : Foo -> : ^^^ ->Foo : typeof Foo -> : ^^^^^^^^^^ - - }); - if (foo) { ->foo : Foo | null -> : ^^^^^^^^^^ - - foo.bar; ->foo.bar : string -> : ^^^^^^ ->foo : Foo -> : ^^^ ->bar : string -> : ^^^^^^ - } -} - -// https://github.com/microsoft/TypeScript/issues/57880 - -const call = (f: () => void) => f(); ->call : (f: () => void) => void -> : ^ ^^ ^^^^^^^^^ ->(f: () => void) => f() : (f: () => void) => void -> : ^ ^^ ^^^^^^^^^ ->f : () => void -> : ^^^^^^ ->f() : void -> : ^^^^ ->f : () => void -> : ^^^^^^ - -const fx3 = () => { ->fx3 : () => void -> : ^^^^^^^^^^ ->() => { let a: undefined | number = undefined; call(() => { a = 1; }); if (a !== undefined) { a.toString(); }} : () => void -> : ^^^^^^^^^^ - - let a: undefined | number = undefined; ->a : number | undefined -> : ^^^^^^^^^^^^^^^^^^ ->undefined : undefined -> : ^^^^^^^^^ - - call(() => { a = 1; }); ->call(() => { a = 1; }) : void -> : ^^^^ ->call : (f: () => void) => void -> : ^ ^^ ^^^^^^^^^ ->() => { a = 1; } : () => void -> : ^^^^^^^^^^ ->a = 1 : 1 -> : ^ ->a : number | undefined -> : ^^^^^^^^^^^^^^^^^^ ->1 : 1 -> : ^ - - if (a !== undefined) { ->a !== undefined : boolean -> : ^^^^^^^ ->a : number | undefined -> : ^^^^^^^^^^^^^^^^^^ ->undefined : undefined -> : ^^^^^^^^^ - - a.toString(); ->a.toString() : string -> : ^^^^^^ ->a.toString : (radix?: number) => string -> : ^ ^^^ ^^^^^ ->a : number -> : ^^^^^^ ->toString : (radix?: number) => string -> : ^ ^^^ ^^^^^ - } -}; - -// https://github.com/microsoft/TypeScript/issues/58291 - -async function execute(onError: (_err: Error | undefined) => void) { ->execute : (onError: (_err: Error | undefined) => void) => Promise -> : ^ ^^ ^^^^^^^^^^^^^^^^^^ ->onError : (_err: Error | undefined) => void -> : ^ ^^ ^^^^^ ->_err : Error | undefined -> : ^^^^^^^^^^^^^^^^^ - - onError(new Error("a")); ->onError(new Error("a")) : void -> : ^^^^ ->onError : (_err: Error | undefined) => void -> : ^ ^^ ^^^^^ ->new Error("a") : Error -> : ^^^^^ ->Error : ErrorConstructor -> : ^^^^^^^^^^^^^^^^ ->"a" : "a" -> : ^^^ -} - -async function run() { ->run : () => Promise -> : ^^^^^^^^^^^^^^^^^^^^^^ - - let result: boolean = true; ->result : boolean -> : ^^^^^^^ ->true : true -> : ^^^^ - - await execute(() => { ->await execute(() => { result = false; }) : void -> : ^^^^ ->execute(() => { result = false; }) : Promise -> : ^^^^^^^^^^^^^ ->execute : (onError: (_err: Error | undefined) => void) => Promise -> : ^ ^^ ^^^^^^^^^^^^^^^^^^ ->() => { result = false; } : () => void -> : ^^^^^^^^^^ - - result = false; ->result = false : false -> : ^^^^^ ->result : boolean -> : ^^^^^^^ ->false : false -> : ^^^^^ - - }); - if (result === false) { ->result === false : boolean -> : ^^^^^^^ ->result : boolean -> : ^^^^^^^ ->false : false -> : ^^^^^ - - console.log("error"); ->console.log("error") : void -> : ^^^^ ->console.log : (...data: any[]) => void -> : ^^^^ ^^ ^^^^^ ->console : Console -> : ^^^^^^^ ->log : (...data: any[]) => void -> : ^^^^ ^^ ^^^^^ ->"error" : "error" -> : ^^^^^^^ - } - return result; ->result : boolean -> : ^^^^^^^ -} - From e037d82f4023007a61ed33a5640b0303479b69ce Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 12 Aug 2024 13:51:00 -0700 Subject: [PATCH 29/30] Handle immediate modifier in strictSubtypeRelation and union signatures --- src/compiler/checker.ts | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 65d0f579f4460..ace096e86da70 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -21378,8 +21378,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { let related = callbacks ? compareSignaturesRelated(targetSig, sourceSig, (checkMode & SignatureCheckMode.StrictArity) | (strictVariance ? SignatureCheckMode.StrictCallback : SignatureCheckMode.BivariantCallback), reportErrors, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) : !(checkMode & SignatureCheckMode.Callback) && !strictVariance && compareTypes(sourceType, targetType, /*reportErrors*/ false) || compareTypes(targetType, sourceType, reportErrors); - // With strict arity, (x: number | undefined) => void is a subtype of (x?: number | undefined) => void - if (related && checkMode & SignatureCheckMode.StrictArity && i >= getMinArgumentCount(source) && i < getMinArgumentCount(target) && compareTypes(sourceType, targetType, /*reportErrors*/ false)) { + // With strict arity, (x: number | undefined) => void is a subtype of (x?: number | undefined) => void, + // and (x: () => void) => void is a subtype of (immediate x: () => void) => void. + if (related && checkMode & SignatureCheckMode.StrictArity && (i >= getMinArgumentCount(source) && i < getMinArgumentCount(target) || isImmediateParameterPosition(source, i) && !isImmediateParameterPosition(target, i)) && compareTypes(sourceType, targetType, /*reportErrors*/ false)) { related = Ternary.False; } if (!related) { @@ -28536,8 +28537,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const saveInitialType = initialType; initialType = getTypeFromFlowType(flowType); let lambdaTypes: Type[] | undefined; - // We assume that lambda arguments may or may not have executed. Thus, lambda arguments can only have a widening - // effect and will have no effect if we already have the declared type (the widest possible type). + // We assume that lambda arguments in 'immediate' parameter positions may or may not have executed. Thus, + // lambda arguments can only have a widening effect and will have no effect if we already have the declared + // type (the widest possible type). if (initialType !== declaredType) { const saveInLambdaArg = inLambdaArg; inLambdaArg = true; @@ -28554,7 +28556,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // circularities. Instead, we simply check if any signature has a deferred callback marker in the // particular argument position. signatures ??= getSignaturesOfType(getTypeOfExpression(flow.node.expression), SignatureKind.Call); - if (some(signatures, sig => !!(getModifiersAtPosition(sig, i) & (ModifierFlags.Immediate | ModifierFlags.JSDocImmediate)))) { + if (some(signatures, sig => isImmediateParameterPosition(sig, i))) { const lambdaType = getTypeFromFlowType(getTypeAtFlowNode(lambda.returnFlowNode)); if (lambdaType !== initialType) { lambdaTypes ??= [initialType]; @@ -37703,9 +37705,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return elementType && isTypeAny(elementType) ? anyType : restType; } - function getModifiersAtPosition(signature: Signature, pos: number) { - const index = pos < signature.parameters.length ? pos : signatureHasRestParameter(signature) ? signature.parameters.length - 1 : -1; - return index >= 0 ? getDeclarationModifierFlagsFromSymbol(signature.parameters[index]) : ModifierFlags.None; + function isImmediateParameterPosition(signature: Signature, pos: number) { + return someSignature(signature, s => { + const index = pos < s.parameters.length ? pos : signatureHasRestParameter(s) ? s.parameters.length - 1 : -1; + return index >= 0 && !!(getDeclarationModifierFlagsFromSymbol(s.parameters[index]) & (ModifierFlags.Immediate | ModifierFlags.JSDocImmediate)); + }); } // Return the number of parameters in a signature. The rest parameter, if present, counts as one From 64e04597240f1befe140a42e3eaef9feffdaf7a9 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 12 Aug 2024 13:51:21 -0700 Subject: [PATCH 30/30] Add tests --- .../reference/immediateCallbacks.errors.txt | 50 ++++ .../reference/immediateCallbacks.symbols | 194 ++++++++++++---- .../reference/immediateCallbacks.types | 216 ++++++++++++++++++ tests/cases/compiler/immediateCallbacks.ts | 50 ++++ 4 files changed, 470 insertions(+), 40 deletions(-) diff --git a/tests/baselines/reference/immediateCallbacks.errors.txt b/tests/baselines/reference/immediateCallbacks.errors.txt index 2d2f723308315..8af77a41da372 100644 --- a/tests/baselines/reference/immediateCallbacks.errors.txt +++ b/tests/baselines/reference/immediateCallbacks.errors.txt @@ -198,6 +198,56 @@ immediateCallbacks.ts(131,14): error TS1070: 'immediate' modifier cannot appear z; // string | number } + // Subtype reduction considers (cb: () => void) => a subtype of (immediate cb: () => void) => void + + declare function fa1(cb1: () => void): void; + declare function fa2(immediate cb2: () => void): void; + + const fa = Math.random() > 0.5 ? fa1 : fa2; + + function fta() { + let x: string | number = "OK"; + fa(() => { + x = 10; + }); + x; // string | number + } + + declare function fb1(cb1: () => void): void; + declare function fb2(immediate cb2: () => void): void; + + const fb = Math.random() > 0.5 ? fb2 : fb1; + + function ftb() { + let x: string | number = "OK"; + fb(() => { + x = 10; + }); + x; // string | number + } + + // A union signature parameter is immediate if any underlying parameter in same position is immediate + + declare const fc: ((immediate cb: () => void) => void) | ((cb: () => void) => void); + + function ftc() { + let x: string | number = "OK"; + fc(() => { + x = 10; + }); + x; // string | number + } + + declare const fd: ((cb: () => void) => void) | ((immediate cb: () => void) => void); + + function ftd() { + let x: string | number = "OK"; + fd(() => { + x = 10; + }); + x; // string | number + } + // https://github.com/microsoft/TypeScript/issues/11498 declare function mystery(immediate cb: () => void): void; diff --git a/tests/baselines/reference/immediateCallbacks.symbols b/tests/baselines/reference/immediateCallbacks.symbols index 6c80081e718a4..5c9c51a50cbf3 100644 --- a/tests/baselines/reference/immediateCallbacks.symbols +++ b/tests/baselines/reference/immediateCallbacks.symbols @@ -491,96 +491,210 @@ function ff4() { >z : Symbol(z, Decl(immediateCallbacks.ts, 168, 7)) } +// Subtype reduction considers (cb: () => void) => a subtype of (immediate cb: () => void) => void + +declare function fa1(cb1: () => void): void; +>fa1 : Symbol(fa1, Decl(immediateCallbacks.ts, 174, 1)) +>cb1 : Symbol(cb1, Decl(immediateCallbacks.ts, 178, 21)) + +declare function fa2(immediate cb2: () => void): void; +>fa2 : Symbol(fa2, Decl(immediateCallbacks.ts, 178, 44)) +>cb2 : Symbol(cb2, Decl(immediateCallbacks.ts, 179, 21)) + +const fa = Math.random() > 0.5 ? fa1 : fa2; +>fa : Symbol(fa, Decl(immediateCallbacks.ts, 181, 5)) +>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>fa1 : Symbol(fa1, Decl(immediateCallbacks.ts, 174, 1)) +>fa2 : Symbol(fa2, Decl(immediateCallbacks.ts, 178, 44)) + +function fta() { +>fta : Symbol(fta, Decl(immediateCallbacks.ts, 181, 43)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(immediateCallbacks.ts, 184, 7)) + + fa(() => { +>fa : Symbol(fa, Decl(immediateCallbacks.ts, 181, 5)) + + x = 10; +>x : Symbol(x, Decl(immediateCallbacks.ts, 184, 7)) + + }); + x; // string | number +>x : Symbol(x, Decl(immediateCallbacks.ts, 184, 7)) +} + +declare function fb1(cb1: () => void): void; +>fb1 : Symbol(fb1, Decl(immediateCallbacks.ts, 189, 1)) +>cb1 : Symbol(cb1, Decl(immediateCallbacks.ts, 191, 21)) + +declare function fb2(immediate cb2: () => void): void; +>fb2 : Symbol(fb2, Decl(immediateCallbacks.ts, 191, 44)) +>cb2 : Symbol(cb2, Decl(immediateCallbacks.ts, 192, 21)) + +const fb = Math.random() > 0.5 ? fb2 : fb1; +>fb : Symbol(fb, Decl(immediateCallbacks.ts, 194, 5)) +>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>fb2 : Symbol(fb2, Decl(immediateCallbacks.ts, 191, 44)) +>fb1 : Symbol(fb1, Decl(immediateCallbacks.ts, 189, 1)) + +function ftb() { +>ftb : Symbol(ftb, Decl(immediateCallbacks.ts, 194, 43)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(immediateCallbacks.ts, 197, 7)) + + fb(() => { +>fb : Symbol(fb, Decl(immediateCallbacks.ts, 194, 5)) + + x = 10; +>x : Symbol(x, Decl(immediateCallbacks.ts, 197, 7)) + + }); + x; // string | number +>x : Symbol(x, Decl(immediateCallbacks.ts, 197, 7)) +} + +// A union signature parameter is immediate if any underlying parameter in same position is immediate + +declare const fc: ((immediate cb: () => void) => void) | ((cb: () => void) => void); +>fc : Symbol(fc, Decl(immediateCallbacks.ts, 206, 13)) +>cb : Symbol(cb, Decl(immediateCallbacks.ts, 206, 20)) +>cb : Symbol(cb, Decl(immediateCallbacks.ts, 206, 59)) + +function ftc() { +>ftc : Symbol(ftc, Decl(immediateCallbacks.ts, 206, 84)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(immediateCallbacks.ts, 209, 7)) + + fc(() => { +>fc : Symbol(fc, Decl(immediateCallbacks.ts, 206, 13)) + + x = 10; +>x : Symbol(x, Decl(immediateCallbacks.ts, 209, 7)) + + }); + x; // string | number +>x : Symbol(x, Decl(immediateCallbacks.ts, 209, 7)) +} + +declare const fd: ((cb: () => void) => void) | ((immediate cb: () => void) => void); +>fd : Symbol(fd, Decl(immediateCallbacks.ts, 216, 13)) +>cb : Symbol(cb, Decl(immediateCallbacks.ts, 216, 20)) +>cb : Symbol(cb, Decl(immediateCallbacks.ts, 216, 49)) + +function ftd() { +>ftd : Symbol(ftd, Decl(immediateCallbacks.ts, 216, 84)) + + let x: string | number = "OK"; +>x : Symbol(x, Decl(immediateCallbacks.ts, 219, 7)) + + fd(() => { +>fd : Symbol(fd, Decl(immediateCallbacks.ts, 216, 13)) + + x = 10; +>x : Symbol(x, Decl(immediateCallbacks.ts, 219, 7)) + + }); + x; // string | number +>x : Symbol(x, Decl(immediateCallbacks.ts, 219, 7)) +} + // https://github.com/microsoft/TypeScript/issues/11498 declare function mystery(immediate cb: () => void): void; ->mystery : Symbol(mystery, Decl(immediateCallbacks.ts, 174, 1)) ->cb : Symbol(cb, Decl(immediateCallbacks.ts, 178, 25)) +>mystery : Symbol(mystery, Decl(immediateCallbacks.ts, 224, 1)) +>cb : Symbol(cb, Decl(immediateCallbacks.ts, 228, 25)) function fx1() { ->fx1 : Symbol(fx1, Decl(immediateCallbacks.ts, 178, 57)) +>fx1 : Symbol(fx1, Decl(immediateCallbacks.ts, 228, 57)) let x: string | number = "OK"; ->x : Symbol(x, Decl(immediateCallbacks.ts, 181, 7)) +>x : Symbol(x, Decl(immediateCallbacks.ts, 231, 7)) x; // string ->x : Symbol(x, Decl(immediateCallbacks.ts, 181, 7)) +>x : Symbol(x, Decl(immediateCallbacks.ts, 231, 7)) mystery(() => { ->mystery : Symbol(mystery, Decl(immediateCallbacks.ts, 174, 1)) +>mystery : Symbol(mystery, Decl(immediateCallbacks.ts, 224, 1)) x = 10; ->x : Symbol(x, Decl(immediateCallbacks.ts, 181, 7)) +>x : Symbol(x, Decl(immediateCallbacks.ts, 231, 7)) }); x; // string | number ->x : Symbol(x, Decl(immediateCallbacks.ts, 181, 7)) +>x : Symbol(x, Decl(immediateCallbacks.ts, 231, 7)) if (x === 10) {} ->x : Symbol(x, Decl(immediateCallbacks.ts, 181, 7)) +>x : Symbol(x, Decl(immediateCallbacks.ts, 231, 7)) } // https://github.com/microsoft/TypeScript/issues/15380 class Foo { ->Foo : Symbol(Foo, Decl(immediateCallbacks.ts, 188, 1)) +>Foo : Symbol(Foo, Decl(immediateCallbacks.ts, 238, 1)) public bar: string = ""; ->bar : Symbol(Foo.bar, Decl(immediateCallbacks.ts, 192, 11)) +>bar : Symbol(Foo.bar, Decl(immediateCallbacks.ts, 242, 11)) } function fx2() { ->fx2 : Symbol(fx2, Decl(immediateCallbacks.ts, 194, 1)) +>fx2 : Symbol(fx2, Decl(immediateCallbacks.ts, 244, 1)) let foo: Foo | null = null; ->foo : Symbol(foo, Decl(immediateCallbacks.ts, 197, 5)) ->Foo : Symbol(Foo, Decl(immediateCallbacks.ts, 188, 1)) +>foo : Symbol(foo, Decl(immediateCallbacks.ts, 247, 5)) +>Foo : Symbol(Foo, Decl(immediateCallbacks.ts, 238, 1)) [1].forEach((item) => { >[1].forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --)) >forEach : Symbol(Array.forEach, Decl(lib.es5.d.ts, --, --)) ->item : Symbol(item, Decl(immediateCallbacks.ts, 198, 15)) +>item : Symbol(item, Decl(immediateCallbacks.ts, 248, 15)) foo = new Foo(); ->foo : Symbol(foo, Decl(immediateCallbacks.ts, 197, 5)) ->Foo : Symbol(Foo, Decl(immediateCallbacks.ts, 188, 1)) +>foo : Symbol(foo, Decl(immediateCallbacks.ts, 247, 5)) +>Foo : Symbol(Foo, Decl(immediateCallbacks.ts, 238, 1)) }); if (foo) { ->foo : Symbol(foo, Decl(immediateCallbacks.ts, 197, 5)) +>foo : Symbol(foo, Decl(immediateCallbacks.ts, 247, 5)) foo.bar; ->foo.bar : Symbol(Foo.bar, Decl(immediateCallbacks.ts, 192, 11)) ->foo : Symbol(foo, Decl(immediateCallbacks.ts, 197, 5)) ->bar : Symbol(Foo.bar, Decl(immediateCallbacks.ts, 192, 11)) +>foo.bar : Symbol(Foo.bar, Decl(immediateCallbacks.ts, 242, 11)) +>foo : Symbol(foo, Decl(immediateCallbacks.ts, 247, 5)) +>bar : Symbol(Foo.bar, Decl(immediateCallbacks.ts, 242, 11)) } } // https://github.com/microsoft/TypeScript/issues/57880 const call = (immediate f: () => void) => f(); ->call : Symbol(call, Decl(immediateCallbacks.ts, 208, 5)) ->f : Symbol(f, Decl(immediateCallbacks.ts, 208, 14)) ->f : Symbol(f, Decl(immediateCallbacks.ts, 208, 14)) +>call : Symbol(call, Decl(immediateCallbacks.ts, 258, 5)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 258, 14)) +>f : Symbol(f, Decl(immediateCallbacks.ts, 258, 14)) const fx3 = () => { ->fx3 : Symbol(fx3, Decl(immediateCallbacks.ts, 210, 5)) +>fx3 : Symbol(fx3, Decl(immediateCallbacks.ts, 260, 5)) let a: undefined | number = undefined; ->a : Symbol(a, Decl(immediateCallbacks.ts, 211, 7)) +>a : Symbol(a, Decl(immediateCallbacks.ts, 261, 7)) >undefined : Symbol(undefined) call(() => { a = 1; }); ->call : Symbol(call, Decl(immediateCallbacks.ts, 208, 5)) ->a : Symbol(a, Decl(immediateCallbacks.ts, 211, 7)) +>call : Symbol(call, Decl(immediateCallbacks.ts, 258, 5)) +>a : Symbol(a, Decl(immediateCallbacks.ts, 261, 7)) if (a !== undefined) { ->a : Symbol(a, Decl(immediateCallbacks.ts, 211, 7)) +>a : Symbol(a, Decl(immediateCallbacks.ts, 261, 7)) >undefined : Symbol(undefined) a.toString(); >a.toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(immediateCallbacks.ts, 211, 7)) +>a : Symbol(a, Decl(immediateCallbacks.ts, 261, 7)) >toString : Symbol(Number.toString, Decl(lib.es5.d.ts, --, --)) } }; @@ -588,31 +702,31 @@ const fx3 = () => { // https://github.com/microsoft/TypeScript/issues/58291 async function execute(immediate onError: (_err: Error | undefined) => void) { ->execute : Symbol(execute, Decl(immediateCallbacks.ts, 216, 2)) ->onError : Symbol(onError, Decl(immediateCallbacks.ts, 220, 23)) ->_err : Symbol(_err, Decl(immediateCallbacks.ts, 220, 43)) +>execute : Symbol(execute, Decl(immediateCallbacks.ts, 266, 2)) +>onError : Symbol(onError, Decl(immediateCallbacks.ts, 270, 23)) +>_err : Symbol(_err, Decl(immediateCallbacks.ts, 270, 43)) >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) onError(new Error("a")); ->onError : Symbol(onError, Decl(immediateCallbacks.ts, 220, 23)) +>onError : Symbol(onError, Decl(immediateCallbacks.ts, 270, 23)) >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) } async function run() { ->run : Symbol(run, Decl(immediateCallbacks.ts, 222, 1)) +>run : Symbol(run, Decl(immediateCallbacks.ts, 272, 1)) let result: boolean = true; ->result : Symbol(result, Decl(immediateCallbacks.ts, 225, 7)) +>result : Symbol(result, Decl(immediateCallbacks.ts, 275, 7)) await execute(() => { ->execute : Symbol(execute, Decl(immediateCallbacks.ts, 216, 2)) +>execute : Symbol(execute, Decl(immediateCallbacks.ts, 266, 2)) result = false; ->result : Symbol(result, Decl(immediateCallbacks.ts, 225, 7)) +>result : Symbol(result, Decl(immediateCallbacks.ts, 275, 7)) }); if (result === false) { ->result : Symbol(result, Decl(immediateCallbacks.ts, 225, 7)) +>result : Symbol(result, Decl(immediateCallbacks.ts, 275, 7)) console.log("error"); >console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) @@ -620,6 +734,6 @@ async function run() { >log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) } return result; ->result : Symbol(result, Decl(immediateCallbacks.ts, 225, 7)) +>result : Symbol(result, Decl(immediateCallbacks.ts, 275, 7)) } diff --git a/tests/baselines/reference/immediateCallbacks.types b/tests/baselines/reference/immediateCallbacks.types index 43d2021c6e5f4..65762f1c9757e 100644 --- a/tests/baselines/reference/immediateCallbacks.types +++ b/tests/baselines/reference/immediateCallbacks.types @@ -778,6 +778,222 @@ function ff4() { > : ^^^^^^^^^^^^^^^ } +// Subtype reduction considers (cb: () => void) => a subtype of (immediate cb: () => void) => void + +declare function fa1(cb1: () => void): void; +>fa1 : (cb1: () => void) => void +> : ^ ^^ ^^^^^ +>cb1 : () => void +> : ^^^^^^ + +declare function fa2(immediate cb2: () => void): void; +>fa2 : (cb2: () => void) => void +> : ^ ^^ ^^^^^ +>cb2 : () => void +> : ^^^^^^ + +const fa = Math.random() > 0.5 ? fa1 : fa2; +>fa : (cb2: () => void) => void +> : ^ ^^ ^^^^^ +>Math.random() > 0.5 ? fa1 : fa2 : (cb2: () => void) => void +> : ^ ^^ ^^^^^ +>Math.random() > 0.5 : boolean +> : ^^^^^^^ +>Math.random() : number +> : ^^^^^^ +>Math.random : () => number +> : ^^^^^^ +>Math : Math +> : ^^^^ +>random : () => number +> : ^^^^^^ +>0.5 : 0.5 +> : ^^^ +>fa1 : (cb1: () => void) => void +> : ^ ^^ ^^^^^ +>fa2 : (cb2: () => void) => void +> : ^ ^^ ^^^^^ + +function fta() { +>fta : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + fa(() => { +>fa(() => { x = 10; }) : void +> : ^^^^ +>fa : (cb2: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = 10; } : () => void +> : ^^^^^^^^^^ + + x = 10; +>x = 10 : 10 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>10 : 10 +> : ^^ + + }); + x; // string | number +>x : string | number +> : ^^^^^^^^^^^^^^^ +} + +declare function fb1(cb1: () => void): void; +>fb1 : (cb1: () => void) => void +> : ^ ^^ ^^^^^ +>cb1 : () => void +> : ^^^^^^ + +declare function fb2(immediate cb2: () => void): void; +>fb2 : (cb2: () => void) => void +> : ^ ^^ ^^^^^ +>cb2 : () => void +> : ^^^^^^ + +const fb = Math.random() > 0.5 ? fb2 : fb1; +>fb : (cb2: () => void) => void +> : ^ ^^ ^^^^^ +>Math.random() > 0.5 ? fb2 : fb1 : (cb2: () => void) => void +> : ^ ^^ ^^^^^ +>Math.random() > 0.5 : boolean +> : ^^^^^^^ +>Math.random() : number +> : ^^^^^^ +>Math.random : () => number +> : ^^^^^^ +>Math : Math +> : ^^^^ +>random : () => number +> : ^^^^^^ +>0.5 : 0.5 +> : ^^^ +>fb2 : (cb2: () => void) => void +> : ^ ^^ ^^^^^ +>fb1 : (cb1: () => void) => void +> : ^ ^^ ^^^^^ + +function ftb() { +>ftb : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + fb(() => { +>fb(() => { x = 10; }) : void +> : ^^^^ +>fb : (cb2: () => void) => void +> : ^ ^^ ^^^^^ +>() => { x = 10; } : () => void +> : ^^^^^^^^^^ + + x = 10; +>x = 10 : 10 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>10 : 10 +> : ^^ + + }); + x; // string | number +>x : string | number +> : ^^^^^^^^^^^^^^^ +} + +// A union signature parameter is immediate if any underlying parameter in same position is immediate + +declare const fc: ((immediate cb: () => void) => void) | ((cb: () => void) => void); +>fc : ((cb: () => void) => void) | ((cb: () => void) => void) +> : ^^ ^^ ^^^^^ ^^^^^^ ^^ ^^^^^ ^ +>cb : () => void +> : ^^^^^^ +>cb : () => void +> : ^^^^^^ + +function ftc() { +>ftc : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + fc(() => { +>fc(() => { x = 10; }) : void +> : ^^^^ +>fc : ((cb: () => void) => void) | ((cb: () => void) => void) +> : ^^ ^^ ^^^^^ ^^^^^^ ^^ ^^^^^ ^ +>() => { x = 10; } : () => void +> : ^^^^^^^^^^ + + x = 10; +>x = 10 : 10 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>10 : 10 +> : ^^ + + }); + x; // string | number +>x : string | number +> : ^^^^^^^^^^^^^^^ +} + +declare const fd: ((cb: () => void) => void) | ((immediate cb: () => void) => void); +>fd : ((cb: () => void) => void) | ((cb: () => void) => void) +> : ^^ ^^ ^^^^^ ^^^^^^ ^^ ^^^^^ ^ +>cb : () => void +> : ^^^^^^ +>cb : () => void +> : ^^^^^^ + +function ftd() { +>ftd : () => void +> : ^^^^^^^^^^ + + let x: string | number = "OK"; +>x : string | number +> : ^^^^^^^^^^^^^^^ +>"OK" : "OK" +> : ^^^^ + + fd(() => { +>fd(() => { x = 10; }) : void +> : ^^^^ +>fd : ((cb: () => void) => void) | ((cb: () => void) => void) +> : ^^ ^^ ^^^^^ ^^^^^^ ^^ ^^^^^ ^ +>() => { x = 10; } : () => void +> : ^^^^^^^^^^ + + x = 10; +>x = 10 : 10 +> : ^^ +>x : string | number +> : ^^^^^^^^^^^^^^^ +>10 : 10 +> : ^^ + + }); + x; // string | number +>x : string | number +> : ^^^^^^^^^^^^^^^ +} + // https://github.com/microsoft/TypeScript/issues/11498 declare function mystery(immediate cb: () => void): void; diff --git a/tests/cases/compiler/immediateCallbacks.ts b/tests/cases/compiler/immediateCallbacks.ts index f8a1129e6fc2b..d2bb257c8d3f5 100644 --- a/tests/cases/compiler/immediateCallbacks.ts +++ b/tests/cases/compiler/immediateCallbacks.ts @@ -178,6 +178,56 @@ function ff4() { z; // string | number } +// Subtype reduction considers (cb: () => void) => a subtype of (immediate cb: () => void) => void + +declare function fa1(cb1: () => void): void; +declare function fa2(immediate cb2: () => void): void; + +const fa = Math.random() > 0.5 ? fa1 : fa2; + +function fta() { + let x: string | number = "OK"; + fa(() => { + x = 10; + }); + x; // string | number +} + +declare function fb1(cb1: () => void): void; +declare function fb2(immediate cb2: () => void): void; + +const fb = Math.random() > 0.5 ? fb2 : fb1; + +function ftb() { + let x: string | number = "OK"; + fb(() => { + x = 10; + }); + x; // string | number +} + +// A union signature parameter is immediate if any underlying parameter in same position is immediate + +declare const fc: ((immediate cb: () => void) => void) | ((cb: () => void) => void); + +function ftc() { + let x: string | number = "OK"; + fc(() => { + x = 10; + }); + x; // string | number +} + +declare const fd: ((cb: () => void) => void) | ((immediate cb: () => void) => void); + +function ftd() { + let x: string | number = "OK"; + fd(() => { + x = 10; + }); + x; // string | number +} + // https://github.com/microsoft/TypeScript/issues/11498 declare function mystery(immediate cb: () => void): void;