npm - typescript - Versions diffs - 4.8.0-dev.20220522 → 4.8.0-dev.20220525 - Mend

typescript 4.8.0-dev.20220522 → 4.8.0-dev.20220525

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/lib/tsc.js +77 -45
package/lib/tsserver.js +102 -58
package/lib/tsserverlibrary.js +102 -58
package/lib/typescript.js +102 -58
package/lib/typescriptServices.js +102 -58
package/lib/typingsInstaller.js +101 -58
package/package.json +1 -1

package/lib/tsserverlibrary.js CHANGED Viewed

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220522";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220525";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -62378,7 +62378,7 @@ var ts;
         function substituteIndexedMappedType(objectType, index) {
             var mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
             var templateMapper = combineTypeMappers(objectType.mapper, mapper);
-            return instantiateType(getTemplateTypeFromMappedType(objectType), templateMapper);
+            return instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper);
         }
         function getIndexedAccessType(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) {
             if (accessFlags === void 0) { accessFlags = 0 /* None */; }
@@ -72490,7 +72490,7 @@ var ts;
                 if (result) {
                     return result;
                 }
-                if (!(contextFlags & 8 /* SkipBindingPatterns */) && ts.isBindingPattern(declaration.name)) { // This is less a contextual type and more an implied shape - in some cases, this may be undesirable
+                if (!(contextFlags & 8 /* SkipBindingPatterns */) && ts.isBindingPattern(declaration.name) && declaration.name.elements.length > 0) {
                     return getTypeFromBindingPattern(declaration.name, /*includePatternInType*/ true, /*reportErrors*/ false);
                 }
             }
@@ -72959,22 +72959,20 @@ var ts;
                 var inferenceContext = getInferenceContext(node);
                 // If no inferences have been made, nothing is gained from instantiating as type parameters
                 // would just be replaced with their defaults similar to the apparent type.
-                if (inferenceContext && ts.some(inferenceContext.inferences, hasInferenceCandidates)) {
+                if (inferenceContext && contextFlags & 1 /* Signature */ && ts.some(inferenceContext.inferences, hasInferenceCandidates)) {
                     // For contextual signatures we incorporate all inferences made so far, e.g. from return
                     // types as well as arguments to the left in a function call.
-                    if (contextFlags && contextFlags & 1 /* Signature */) {
-                        return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
-                    }
+                    return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
+                }
+                if (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnMapper) {
                     // For other purposes (e.g. determining whether to produce literal types) we only
                     // incorporate inferences made from the return type in a function call. We remove
                     // the 'boolean' type from the contextual type such that contextually typed boolean
                     // literals actually end up widening to 'boolean' (see #48363).
-                    if (inferenceContext.returnMapper) {
-                        var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
-                        return type.flags & 1048576 /* Union */ && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
-                            filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
-                            type;
-                    }
+                    var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
+                    return type.flags & 1048576 /* Union */ && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
+                        filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
+                        type;
                 }
             }
             return contextualType;
@@ -75508,29 +75506,43 @@ var ts;
             // 'let f: (x: string) => number = wrap(s => s.length)', we infer from the declared type of 'f' to the
             // return type of 'wrap'.
             if (node.kind !== 165 /* Decorator */) {
-                var contextualType = getContextualType(node, ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); }) ? 8 /* SkipBindingPatterns */ : 0 /* None */);
+                var skipBindingPatterns = ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); });
+                var contextualType = getContextualType(node, skipBindingPatterns ? 8 /* SkipBindingPatterns */ : 0 /* None */);
                 if (contextualType) {
                     var inferenceTargetType = getReturnTypeOfSignature(signature);
                     if (couldContainTypeVariables(inferenceTargetType)) {
-                        // We clone the inference context to avoid disturbing a resolution in progress for an
-                        // outer call expression. Effectively we just want a snapshot of whatever has been
-                        // inferred for any outer call expression so far.
                         var outerContext = getInferenceContext(node);
-                        var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1 /* NoDefault */));
-                        var instantiatedType = instantiateType(contextualType, outerMapper);
-                        // If the contextual type is a generic function type with a single call signature, we
-                        // instantiate the type with its own type parameters and type arguments. This ensures that
-                        // the type parameters are not erased to type any during type inference such that they can
-                        // be inferred as actual types from the contextual type. For example:
-                        //   declare function arrayMap<T, U>(f: (x: T) => U): (a: T[]) => U[];
-                        //   const boxElements: <A>(a: A[]) => { value: A }[] = arrayMap(value => ({ value }));
-                        // Above, the type of the 'value' parameter is inferred to be 'A'.
-                        var contextualSignature = getSingleCallSignature(instantiatedType);
-                        var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
-                            getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
-                            instantiatedType;
-                        // Inferences made from return types have lower priority than all other inferences.
-                        inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
+                        var isFromBindingPattern = !skipBindingPatterns && getContextualType(node, 8 /* SkipBindingPatterns */) !== contextualType;
+                        // A return type inference from a binding pattern can be used in instantiating the contextual
+                        // type of an argument later in inference, but cannot stand on its own as the final return type.
+                        // It is incorporated into `context.returnMapper` which is used in `instantiateContextualType`,
+                        // but doesn't need to go into `context.inferences`. This allows a an array binding pattern to
+                        // produce a tuple for `T` in
+                        //   declare function f<T>(cb: () => T): T;
+                        //   const [e1, e2, e3] = f(() => [1, "hi", true]);
+                        // but does not produce any inference for `T` in
+                        //   declare function f<T>(): T;
+                        //   const [e1, e2, e3] = f();
+                        if (!isFromBindingPattern) {
+                            // We clone the inference context to avoid disturbing a resolution in progress for an
+                            // outer call expression. Effectively we just want a snapshot of whatever has been
+                            // inferred for any outer call expression so far.
+                            var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1 /* NoDefault */));
+                            var instantiatedType = instantiateType(contextualType, outerMapper);
+                            // If the contextual type is a generic function type with a single call signature, we
+                            // instantiate the type with its own type parameters and type arguments. This ensures that
+                            // the type parameters are not erased to type any during type inference such that they can
+                            // be inferred as actual types from the contextual type. For example:
+                            //   declare function arrayMap<T, U>(f: (x: T) => U): (a: T[]) => U[];
+                            //   const boxElements: <A>(a: A[]) => { value: A }[] = arrayMap(value => ({ value }));
+                            // Above, the type of the 'value' parameter is inferred to be 'A'.
+                            var contextualSignature = getSingleCallSignature(instantiatedType);
+                            var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
+                                getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
+                                instantiatedType;
+                            // Inferences made from return types have lower priority than all other inferences.
+                            inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
+                        }
                         // Create a type mapper for instantiating generic contextual types using the inferences made
                         // from the return type. We need a separate inference pass here because (a) instantiation of
                         // the source type uses the outer context's return mapper (which excludes inferences made from
@@ -107455,7 +107467,7 @@ var ts;
                     // Though an error in es2020 modules, in node-flavor es2020 modules, we can helpfully transform this to a synthetic `require` call
                     // To give easy access to a synchronous `require` in node-flavor esm. We do the transform even in scenarios where we error, but `import.meta.url`
                     // is available, just because the output is reasonable for a node-like runtime.
-                    return ts.getEmitScriptTarget(compilerOptions) >= ts.ModuleKind.ES2020 ? visitImportEqualsDeclaration(node) : undefined;
+                    return ts.getEmitModuleKind(compilerOptions) >= ts.ModuleKind.Node16 ? visitImportEqualsDeclaration(node) : undefined;
                 case 271 /* ExportAssignment */:
                     return visitExportAssignment(node);
                 case 272 /* ExportDeclaration */:
@@ -124286,7 +124298,6 @@ var ts;
             allProjectBuildPending: true,
             needsSummary: true,
             watchAllProjectsPending: watch,
-            currentInvalidatedProject: undefined,
             // Watch state
             watch: watch,
             allWatchedWildcardDirectories: new ts.Map(),
@@ -124519,7 +124530,6 @@ var ts;
     })(InvalidatedProjectKind = ts.InvalidatedProjectKind || (ts.InvalidatedProjectKind = {}));
     function doneInvalidatedProject(state, projectPath) {
         state.projectPendingBuild.delete(projectPath);
-        state.currentInvalidatedProject = undefined;
         return state.diagnostics.has(projectPath) ?
             ts.ExitStatus.DiagnosticsPresent_OutputsSkipped :
             ts.ExitStatus.Success;
@@ -124870,17 +124880,11 @@ var ts;
             !!ts.getConfigFileParsingDiagnostics(config).length ||
             !ts.isIncrementalCompilation(config.options);
     }
-    function getNextInvalidatedProject(state, buildOrder, reportQueue) {
+    function getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue) {
         if (!state.projectPendingBuild.size)
             return undefined;
         if (isCircularBuildOrder(buildOrder))
             return undefined;
-        if (state.currentInvalidatedProject) {
-            // Only if same buildOrder the currentInvalidated project can be sent again
-            return ts.arrayIsEqualTo(state.currentInvalidatedProject.buildOrder, buildOrder) ?
-                state.currentInvalidatedProject :
-                undefined;
-        }
         var options = state.options, projectPendingBuild = state.projectPendingBuild;
         for (var projectIndex = 0; projectIndex < buildOrder.length; projectIndex++) {
             var project = buildOrder[projectIndex];
@@ -124913,9 +124917,9 @@ var ts;
                 watchPackageJsonFiles(state, project, projectPath, config);
             }
             var status = getUpToDateStatus(state, config, projectPath);
-            verboseReportProjectStatus(state, project, status);
             if (!options.force) {
                 if (status.type === ts.UpToDateStatusType.UpToDate) {
+                    verboseReportProjectStatus(state, project, status);
                     reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                     projectPendingBuild.delete(projectPath);
                     // Up to date, skip
@@ -124927,10 +124931,18 @@ var ts;
                 }
                 if (status.type === ts.UpToDateStatusType.UpToDateWithUpstreamTypes) {
                     reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
-                    return createUpdateOutputFileStampsProject(state, project, projectPath, config, buildOrder);
+                    return {
+                        kind: InvalidatedProjectKind.UpdateOutputFileStamps,
+                        status: status,
+                        project: project,
+                        projectPath: projectPath,
+                        projectIndex: projectIndex,
+                        config: config
+                    };
                 }
             }
             if (status.type === ts.UpToDateStatusType.UpstreamBlocked) {
+                verboseReportProjectStatus(state, project, status);
                 reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                 projectPendingBuild.delete(projectPath);
                 if (options.verbose) {
@@ -124941,17 +124953,37 @@ var ts;
                 continue;
             }
             if (status.type === ts.UpToDateStatusType.ContainerOnly) {
+                verboseReportProjectStatus(state, project, status);
                 reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                 projectPendingBuild.delete(projectPath);
                 // Do nothing
                 continue;
             }
-            return createBuildOrUpdateInvalidedProject(needsBuild(state, status, config) ?
-                InvalidatedProjectKind.Build :
-                InvalidatedProjectKind.UpdateBundle, state, project, projectPath, projectIndex, config, buildOrder);
+            return {
+                kind: needsBuild(state, status, config) ?
+                    InvalidatedProjectKind.Build :
+                    InvalidatedProjectKind.UpdateBundle,
+                status: status,
+                project: project,
+                projectPath: projectPath,
+                projectIndex: projectIndex,
+                config: config,
+            };
         }
         return undefined;
     }
+    function createInvalidatedProjectWithInfo(state, info, buildOrder) {
+        verboseReportProjectStatus(state, info.project, info.status);
+        return info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps ?
+            createBuildOrUpdateInvalidedProject(info.kind, state, info.project, info.projectPath, info.projectIndex, info.config, buildOrder) :
+            createUpdateOutputFileStampsProject(state, info.project, info.projectPath, info.config, buildOrder);
+    }
+    function getNextInvalidatedProject(state, buildOrder, reportQueue) {
+        var info = getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue);
+        if (!info)
+            return info;
+        return createInvalidatedProjectWithInfo(state, info, buildOrder);
+    }
     function listEmittedFile(_a, proj, file) {
         var write = _a.write;
         if (write && proj.options.listEmittedFiles) {
@@ -125392,9 +125424,9 @@ var ts;
     function invalidateProjectAndScheduleBuilds(state, resolvedPath, reloadLevel) {
         state.reportFileChangeDetected = true;
         invalidateProject(state, resolvedPath, reloadLevel);
-        scheduleBuildInvalidatedProject(state);
+        scheduleBuildInvalidatedProject(state, 250, /*changeDetected*/ true);
     }
-    function scheduleBuildInvalidatedProject(state) {
+    function scheduleBuildInvalidatedProject(state, time, changeDetected) {
         var hostWithWatch = state.hostWithWatch;
         if (!hostWithWatch.setTimeout || !hostWithWatch.clearTimeout) {
             return;
@@ -125402,25 +125434,38 @@ var ts;
         if (state.timerToBuildInvalidatedProject) {
             hostWithWatch.clearTimeout(state.timerToBuildInvalidatedProject);
         }
-        state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, 250, state);
+        state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, time, state, changeDetected);
     }
-    function buildNextInvalidatedProject(state) {
+    function buildNextInvalidatedProject(state, changeDetected) {
         state.timerToBuildInvalidatedProject = undefined;
         if (state.reportFileChangeDetected) {
             state.reportFileChangeDetected = false;
             state.projectErrorsReported.clear();
             reportWatchStatus(state, ts.Diagnostics.File_change_detected_Starting_incremental_compilation);
         }
+        var projectsBuilt = 0;
         var buildOrder = getBuildOrder(state);
         var invalidatedProject = getNextInvalidatedProject(state, buildOrder, /*reportQueue*/ false);
         if (invalidatedProject) {
             invalidatedProject.done();
-            if (state.projectPendingBuild.size) {
-                // Schedule next project for build
-                if (state.watch && !state.timerToBuildInvalidatedProject) {
-                    scheduleBuildInvalidatedProject(state);
+            projectsBuilt++;
+            while (state.projectPendingBuild.size) {
+                // If already scheduled, skip
+                if (state.timerToBuildInvalidatedProject)
+                    return;
+                // Before scheduling check if the next project needs build
+                var info = getNextInvalidatedProjectCreateInfo(state, buildOrder, /*reportQueue*/ false);
+                if (!info)
+                    break; // Nothing to build any more
+                if (info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps && (changeDetected || projectsBuilt === 5)) {
+                    // Schedule next project for build
+                    scheduleBuildInvalidatedProject(state, 100, /*changeDetected*/ false);
+                    return;
                 }
-                return;
+                var project = createInvalidatedProjectWithInfo(state, info, buildOrder);
+                project.done();
+                if (info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps)
+                    projectsBuilt++;
             }
         }
         disableCache(state);
@@ -125524,8 +125569,6 @@ var ts;
                 return getUpToDateStatus(state, parseConfigFile(state, configFileName, configFilePath), configFilePath);
             },
             invalidateProject: function (configFilePath, reloadLevel) { return invalidateProject(state, configFilePath, reloadLevel || ts.ConfigFileProgramReloadLevel.None); },
-            buildNextInvalidatedProject: function () { return buildNextInvalidatedProject(state); },
-            getAllParsedConfigs: function () { return ts.arrayFrom(ts.mapDefinedIterator(state.configFileCache.values(), function (config) { return isParsedCommandLine(config) ? config : undefined; })); },
             close: function () { return stopWatching(state); },
         };
     }
@@ -135278,6 +135321,7 @@ var ts;
             return kind === 131 /* AsyncKeyword */
                 || kind === 132 /* AwaitKeyword */
                 || kind === 127 /* AsKeyword */
+                || kind === 152 /* TypeKeyword */
                 || !ts.isContextualKeyword(kind) && !isClassMemberCompletionKeyword(kind);
         }
         function keywordForNode(node) {

package/lib/typescript.js CHANGED Viewed

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220522";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220525";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -62378,7 +62378,7 @@ var ts;
         function substituteIndexedMappedType(objectType, index) {
             var mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
             var templateMapper = combineTypeMappers(objectType.mapper, mapper);
-            return instantiateType(getTemplateTypeFromMappedType(objectType), templateMapper);
+            return instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper);
         }
         function getIndexedAccessType(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) {
             if (accessFlags === void 0) { accessFlags = 0 /* None */; }
@@ -72490,7 +72490,7 @@ var ts;
                 if (result) {
                     return result;
                 }
-                if (!(contextFlags & 8 /* SkipBindingPatterns */) && ts.isBindingPattern(declaration.name)) { // This is less a contextual type and more an implied shape - in some cases, this may be undesirable
+                if (!(contextFlags & 8 /* SkipBindingPatterns */) && ts.isBindingPattern(declaration.name) && declaration.name.elements.length > 0) {
                     return getTypeFromBindingPattern(declaration.name, /*includePatternInType*/ true, /*reportErrors*/ false);
                 }
             }
@@ -72959,22 +72959,20 @@ var ts;
                 var inferenceContext = getInferenceContext(node);
                 // If no inferences have been made, nothing is gained from instantiating as type parameters
                 // would just be replaced with their defaults similar to the apparent type.
-                if (inferenceContext && ts.some(inferenceContext.inferences, hasInferenceCandidates)) {
+                if (inferenceContext && contextFlags & 1 /* Signature */ && ts.some(inferenceContext.inferences, hasInferenceCandidates)) {
                     // For contextual signatures we incorporate all inferences made so far, e.g. from return
                     // types as well as arguments to the left in a function call.
-                    if (contextFlags && contextFlags & 1 /* Signature */) {
-                        return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
-                    }
+                    return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
+                }
+                if (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnMapper) {
                     // For other purposes (e.g. determining whether to produce literal types) we only
                     // incorporate inferences made from the return type in a function call. We remove
                     // the 'boolean' type from the contextual type such that contextually typed boolean
                     // literals actually end up widening to 'boolean' (see #48363).
-                    if (inferenceContext.returnMapper) {
-                        var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
-                        return type.flags & 1048576 /* Union */ && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
-                            filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
-                            type;
-                    }
+                    var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
+                    return type.flags & 1048576 /* Union */ && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ?
+                        filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) :
+                        type;
                 }
             }
             return contextualType;
@@ -75508,29 +75506,43 @@ var ts;
             // 'let f: (x: string) => number = wrap(s => s.length)', we infer from the declared type of 'f' to the
             // return type of 'wrap'.
             if (node.kind !== 165 /* Decorator */) {
-                var contextualType = getContextualType(node, ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); }) ? 8 /* SkipBindingPatterns */ : 0 /* None */);
+                var skipBindingPatterns = ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); });
+                var contextualType = getContextualType(node, skipBindingPatterns ? 8 /* SkipBindingPatterns */ : 0 /* None */);
                 if (contextualType) {
                     var inferenceTargetType = getReturnTypeOfSignature(signature);
                     if (couldContainTypeVariables(inferenceTargetType)) {
-                        // We clone the inference context to avoid disturbing a resolution in progress for an
-                        // outer call expression. Effectively we just want a snapshot of whatever has been
-                        // inferred for any outer call expression so far.
                         var outerContext = getInferenceContext(node);
-                        var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1 /* NoDefault */));
-                        var instantiatedType = instantiateType(contextualType, outerMapper);
-                        // If the contextual type is a generic function type with a single call signature, we
-                        // instantiate the type with its own type parameters and type arguments. This ensures that
-                        // the type parameters are not erased to type any during type inference such that they can
-                        // be inferred as actual types from the contextual type. For example:
-                        //   declare function arrayMap<T, U>(f: (x: T) => U): (a: T[]) => U[];
-                        //   const boxElements: <A>(a: A[]) => { value: A }[] = arrayMap(value => ({ value }));
-                        // Above, the type of the 'value' parameter is inferred to be 'A'.
-                        var contextualSignature = getSingleCallSignature(instantiatedType);
-                        var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
-                            getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
-                            instantiatedType;
-                        // Inferences made from return types have lower priority than all other inferences.
-                        inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
+                        var isFromBindingPattern = !skipBindingPatterns && getContextualType(node, 8 /* SkipBindingPatterns */) !== contextualType;
+                        // A return type inference from a binding pattern can be used in instantiating the contextual
+                        // type of an argument later in inference, but cannot stand on its own as the final return type.
+                        // It is incorporated into `context.returnMapper` which is used in `instantiateContextualType`,
+                        // but doesn't need to go into `context.inferences`. This allows a an array binding pattern to
+                        // produce a tuple for `T` in
+                        //   declare function f<T>(cb: () => T): T;
+                        //   const [e1, e2, e3] = f(() => [1, "hi", true]);
+                        // but does not produce any inference for `T` in
+                        //   declare function f<T>(): T;
+                        //   const [e1, e2, e3] = f();
+                        if (!isFromBindingPattern) {
+                            // We clone the inference context to avoid disturbing a resolution in progress for an
+                            // outer call expression. Effectively we just want a snapshot of whatever has been
+                            // inferred for any outer call expression so far.
+                            var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1 /* NoDefault */));
+                            var instantiatedType = instantiateType(contextualType, outerMapper);
+                            // If the contextual type is a generic function type with a single call signature, we
+                            // instantiate the type with its own type parameters and type arguments. This ensures that
+                            // the type parameters are not erased to type any during type inference such that they can
+                            // be inferred as actual types from the contextual type. For example:
+                            //   declare function arrayMap<T, U>(f: (x: T) => U): (a: T[]) => U[];
+                            //   const boxElements: <A>(a: A[]) => { value: A }[] = arrayMap(value => ({ value }));
+                            // Above, the type of the 'value' parameter is inferred to be 'A'.
+                            var contextualSignature = getSingleCallSignature(instantiatedType);
+                            var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
+                                getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) :
+                                instantiatedType;
+                            // Inferences made from return types have lower priority than all other inferences.
+                            inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
+                        }
                         // Create a type mapper for instantiating generic contextual types using the inferences made
                         // from the return type. We need a separate inference pass here because (a) instantiation of
                         // the source type uses the outer context's return mapper (which excludes inferences made from
@@ -107455,7 +107467,7 @@ var ts;
                     // Though an error in es2020 modules, in node-flavor es2020 modules, we can helpfully transform this to a synthetic `require` call
                     // To give easy access to a synchronous `require` in node-flavor esm. We do the transform even in scenarios where we error, but `import.meta.url`
                     // is available, just because the output is reasonable for a node-like runtime.
-                    return ts.getEmitScriptTarget(compilerOptions) >= ts.ModuleKind.ES2020 ? visitImportEqualsDeclaration(node) : undefined;
+                    return ts.getEmitModuleKind(compilerOptions) >= ts.ModuleKind.Node16 ? visitImportEqualsDeclaration(node) : undefined;
                 case 271 /* ExportAssignment */:
                     return visitExportAssignment(node);
                 case 272 /* ExportDeclaration */:
@@ -124286,7 +124298,6 @@ var ts;
             allProjectBuildPending: true,
             needsSummary: true,
             watchAllProjectsPending: watch,
-            currentInvalidatedProject: undefined,
             // Watch state
             watch: watch,
             allWatchedWildcardDirectories: new ts.Map(),
@@ -124519,7 +124530,6 @@ var ts;
     })(InvalidatedProjectKind = ts.InvalidatedProjectKind || (ts.InvalidatedProjectKind = {}));
     function doneInvalidatedProject(state, projectPath) {
         state.projectPendingBuild.delete(projectPath);
-        state.currentInvalidatedProject = undefined;
         return state.diagnostics.has(projectPath) ?
             ts.ExitStatus.DiagnosticsPresent_OutputsSkipped :
             ts.ExitStatus.Success;
@@ -124870,17 +124880,11 @@ var ts;
             !!ts.getConfigFileParsingDiagnostics(config).length ||
             !ts.isIncrementalCompilation(config.options);
     }
-    function getNextInvalidatedProject(state, buildOrder, reportQueue) {
+    function getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue) {
         if (!state.projectPendingBuild.size)
             return undefined;
         if (isCircularBuildOrder(buildOrder))
             return undefined;
-        if (state.currentInvalidatedProject) {
-            // Only if same buildOrder the currentInvalidated project can be sent again
-            return ts.arrayIsEqualTo(state.currentInvalidatedProject.buildOrder, buildOrder) ?
-                state.currentInvalidatedProject :
-                undefined;
-        }
         var options = state.options, projectPendingBuild = state.projectPendingBuild;
         for (var projectIndex = 0; projectIndex < buildOrder.length; projectIndex++) {
             var project = buildOrder[projectIndex];
@@ -124913,9 +124917,9 @@ var ts;
                 watchPackageJsonFiles(state, project, projectPath, config);
             }
             var status = getUpToDateStatus(state, config, projectPath);
-            verboseReportProjectStatus(state, project, status);
             if (!options.force) {
                 if (status.type === ts.UpToDateStatusType.UpToDate) {
+                    verboseReportProjectStatus(state, project, status);
                     reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                     projectPendingBuild.delete(projectPath);
                     // Up to date, skip
@@ -124927,10 +124931,18 @@ var ts;
                 }
                 if (status.type === ts.UpToDateStatusType.UpToDateWithUpstreamTypes) {
                     reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
-                    return createUpdateOutputFileStampsProject(state, project, projectPath, config, buildOrder);
+                    return {
+                        kind: InvalidatedProjectKind.UpdateOutputFileStamps,
+                        status: status,
+                        project: project,
+                        projectPath: projectPath,
+                        projectIndex: projectIndex,
+                        config: config
+                    };
                 }
             }
             if (status.type === ts.UpToDateStatusType.UpstreamBlocked) {
+                verboseReportProjectStatus(state, project, status);
                 reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                 projectPendingBuild.delete(projectPath);
                 if (options.verbose) {
@@ -124941,17 +124953,37 @@ var ts;
                 continue;
             }
             if (status.type === ts.UpToDateStatusType.ContainerOnly) {
+                verboseReportProjectStatus(state, project, status);
                 reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                 projectPendingBuild.delete(projectPath);
                 // Do nothing
                 continue;
             }
-            return createBuildOrUpdateInvalidedProject(needsBuild(state, status, config) ?
-                InvalidatedProjectKind.Build :
-                InvalidatedProjectKind.UpdateBundle, state, project, projectPath, projectIndex, config, buildOrder);
+            return {
+                kind: needsBuild(state, status, config) ?
+                    InvalidatedProjectKind.Build :
+                    InvalidatedProjectKind.UpdateBundle,
+                status: status,
+                project: project,
+                projectPath: projectPath,
+                projectIndex: projectIndex,
+                config: config,
+            };
         }
         return undefined;
     }
+    function createInvalidatedProjectWithInfo(state, info, buildOrder) {
+        verboseReportProjectStatus(state, info.project, info.status);
+        return info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps ?
+            createBuildOrUpdateInvalidedProject(info.kind, state, info.project, info.projectPath, info.projectIndex, info.config, buildOrder) :
+            createUpdateOutputFileStampsProject(state, info.project, info.projectPath, info.config, buildOrder);
+    }
+    function getNextInvalidatedProject(state, buildOrder, reportQueue) {
+        var info = getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue);
+        if (!info)
+            return info;
+        return createInvalidatedProjectWithInfo(state, info, buildOrder);
+    }
     function listEmittedFile(_a, proj, file) {
         var write = _a.write;
         if (write && proj.options.listEmittedFiles) {
@@ -125392,9 +125424,9 @@ var ts;
     function invalidateProjectAndScheduleBuilds(state, resolvedPath, reloadLevel) {
         state.reportFileChangeDetected = true;
         invalidateProject(state, resolvedPath, reloadLevel);
-        scheduleBuildInvalidatedProject(state);
+        scheduleBuildInvalidatedProject(state, 250, /*changeDetected*/ true);
     }
-    function scheduleBuildInvalidatedProject(state) {
+    function scheduleBuildInvalidatedProject(state, time, changeDetected) {
         var hostWithWatch = state.hostWithWatch;
         if (!hostWithWatch.setTimeout || !hostWithWatch.clearTimeout) {
             return;
@@ -125402,25 +125434,38 @@ var ts;
         if (state.timerToBuildInvalidatedProject) {
             hostWithWatch.clearTimeout(state.timerToBuildInvalidatedProject);
         }
-        state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, 250, state);
+        state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, time, state, changeDetected);
     }
-    function buildNextInvalidatedProject(state) {
+    function buildNextInvalidatedProject(state, changeDetected) {
         state.timerToBuildInvalidatedProject = undefined;
         if (state.reportFileChangeDetected) {
             state.reportFileChangeDetected = false;
             state.projectErrorsReported.clear();
             reportWatchStatus(state, ts.Diagnostics.File_change_detected_Starting_incremental_compilation);
         }
+        var projectsBuilt = 0;
         var buildOrder = getBuildOrder(state);
         var invalidatedProject = getNextInvalidatedProject(state, buildOrder, /*reportQueue*/ false);
         if (invalidatedProject) {
             invalidatedProject.done();
-            if (state.projectPendingBuild.size) {
-                // Schedule next project for build
-                if (state.watch && !state.timerToBuildInvalidatedProject) {
-                    scheduleBuildInvalidatedProject(state);
+            projectsBuilt++;
+            while (state.projectPendingBuild.size) {
+                // If already scheduled, skip
+                if (state.timerToBuildInvalidatedProject)
+                    return;
+                // Before scheduling check if the next project needs build
+                var info = getNextInvalidatedProjectCreateInfo(state, buildOrder, /*reportQueue*/ false);
+                if (!info)
+                    break; // Nothing to build any more
+                if (info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps && (changeDetected || projectsBuilt === 5)) {
+                    // Schedule next project for build
+                    scheduleBuildInvalidatedProject(state, 100, /*changeDetected*/ false);
+                    return;
                 }
-                return;
+                var project = createInvalidatedProjectWithInfo(state, info, buildOrder);
+                project.done();
+                if (info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps)
+                    projectsBuilt++;
             }
         }
         disableCache(state);
@@ -125524,8 +125569,6 @@ var ts;
                 return getUpToDateStatus(state, parseConfigFile(state, configFileName, configFilePath), configFilePath);
             },
             invalidateProject: function (configFilePath, reloadLevel) { return invalidateProject(state, configFilePath, reloadLevel || ts.ConfigFileProgramReloadLevel.None); },
-            buildNextInvalidatedProject: function () { return buildNextInvalidatedProject(state); },
-            getAllParsedConfigs: function () { return ts.arrayFrom(ts.mapDefinedIterator(state.configFileCache.values(), function (config) { return isParsedCommandLine(config) ? config : undefined; })); },
             close: function () { return stopWatching(state); },
         };
     }
@@ -135278,6 +135321,7 @@ var ts;
             return kind === 131 /* AsyncKeyword */
                 || kind === 132 /* AwaitKeyword */
                 || kind === 127 /* AsKeyword */
+                || kind === 152 /* TypeKeyword */
                 || !ts.isContextualKeyword(kind) && !isClassMemberCompletionKeyword(kind);
         }
         function keywordForNode(node) {