typescript 4.8.0-dev.20220612 → 4.8.0-dev.20220615

package/lib/tsserver.js

@@ -92,6 +92,15 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var ts;
 (function (ts) {
     // WARNING: The script `configurePrerelease.ts` uses a regexp to parse out these values.
@@ -100,7 +109,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.20220612";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220615";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8962,6 +8971,8 @@ var ts;
         This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value: diag(2839, ts.DiagnosticCategory.Error, "This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value_2839", "This condition will always return '{0}' since JavaScript compares objects by reference, not value."),
         An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes: diag(2840, ts.DiagnosticCategory.Error, "An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_clas_2840", "An interface cannot extend a primitive type like '{0}'; an interface can only extend named types and classes"),
         The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_feature_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(2841, ts.DiagnosticCategory.Error, "The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_2841", "The type of this expression cannot be named without a 'resolution-mode' assertion, which is an unstable feature. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."),
+        _0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation: diag(2842, ts.DiagnosticCategory.Error, "_0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation_2842", "'{0}' is an unused renaming of '{1}'. Did you intend to use it as a type annotation?"),
+        We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here: diag(2843, ts.DiagnosticCategory.Error, "We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here_2843", "We can only write a type for '{0}' by adding a type for the entire parameter here."),
         Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -49193,6 +49204,7 @@ var ts;
         var potentialNewTargetCollisions = [];
         var potentialWeakMapSetCollisions = [];
         var potentialReflectCollisions = [];
+        var potentialUnusedRenamedBindingElementsInTypes = [];
         var awaitedTypeStack = [];
         var diagnostics = ts.createDiagnosticCollection();
         var suggestionDiagnostics = ts.createDiagnosticCollection();
@@ -53700,15 +53712,22 @@ var ts;
                 context.approximateLength += ts.symbolName(parameterSymbol).length + 3;
                 return parameterNode;
                 function cloneBindingName(node) {
-                    return elideInitializerAndSetEmitFlags(node);
-                    function elideInitializerAndSetEmitFlags(node) {
+                    return elideInitializerAndPropertyRenamingAndSetEmitFlags(node);
+                    function elideInitializerAndPropertyRenamingAndSetEmitFlags(node) {
                         if (context.tracker.trackSymbol && ts.isComputedPropertyName(node) && isLateBindableName(node)) {
                             trackComputedName(node.expression, context.enclosingDeclaration, context);
                         }
-                        var visited = ts.visitEachChild(node, elideInitializerAndSetEmitFlags, ts.nullTransformationContext, /*nodesVisitor*/ undefined, elideInitializerAndSetEmitFlags);
+                        var visited = ts.visitEachChild(node, elideInitializerAndPropertyRenamingAndSetEmitFlags, ts.nullTransformationContext, /*nodesVisitor*/ undefined, elideInitializerAndPropertyRenamingAndSetEmitFlags);
                         if (ts.isBindingElement(visited)) {
-                            visited = ts.factory.updateBindingElement(visited, visited.dotDotDotToken, visited.propertyName, visited.name, 
-                            /*initializer*/ undefined);
+                            if (visited.propertyName && ts.isIdentifier(visited.propertyName) && ts.isIdentifier(visited.name)) {
+                                visited = ts.factory.updateBindingElement(visited, visited.dotDotDotToken, 
+                                /* propertyName*/ undefined, visited.propertyName, 
+                                /*initializer*/ undefined);
+                            }
+                            else {
+                                visited = ts.factory.updateBindingElement(visited, visited.dotDotDotToken, visited.propertyName, visited.name, 
+                                /*initializer*/ undefined);
+                            }
                         }
                         if (!ts.nodeIsSynthesized(visited)) {
                             visited = ts.factory.cloneNode(visited);
@@ -64918,7 +64937,7 @@ var ts;
                 return true;
             if (s & 65536 /* Null */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & 65536 /* Null */))
                 return true;
-            if (s & 524288 /* Object */ && t & 67108864 /* NonPrimitive */ && !(relation === strictSubtypeRelation && isEmptyAnonymousObjectType(source)))
+            if (s & 524288 /* Object */ && t & 67108864 /* NonPrimitive */ && !(relation === strictSubtypeRelation && isEmptyAnonymousObjectType(source) && !(ts.getObjectFlags(source) & 8192 /* FreshLiteral */)))
                 return true;
             if (relation === assignableRelation || relation === comparableRelation) {
                 if (s & 1 /* Any */)
@@ -65621,7 +65640,7 @@ var ts;
                     return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source), target, reportErrors && !(source.flags & 131068 /* Primitive */) && !(target.flags & 131068 /* Primitive */));
                 }
                 if (target.flags & 2097152 /* Intersection */) {
-                    return typeRelatedToEachType(getRegularTypeOfObjectLiteral(source), target, reportErrors, 2 /* Target */);
+                    return typeRelatedToEachType(source, target, reportErrors, 2 /* Target */);
                 }
                 // Source is an intersection. For the comparable relation, if the target is a primitive type we hoist the
                 // constraints of all non-primitive types in the source into a new intersection. We do this because the
@@ -68032,12 +68051,13 @@ var ts;
          * with no call or construct signatures.
          */
         function isObjectTypeWithInferableIndex(type) {
+            var objectFlags = ts.getObjectFlags(type);
             return type.flags & 2097152 /* Intersection */
                 ? ts.every(type.types, isObjectTypeWithInferableIndex)
                 : !!(type.symbol
                     && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */ | 384 /* Enum */ | 512 /* ValueModule */)) !== 0
                     && !(type.symbol.flags & 32 /* Class */)
-                    && !typeHasCallOrConstructSignatures(type)) || !!(ts.getObjectFlags(type) & 1024 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
+                    && !typeHasCallOrConstructSignatures(type)) || !!(objectFlags & 4194304 /* ObjectRestType */) || !!(objectFlags & 1024 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
         }
         function createSymbolWithType(source, type) {
             var symbol = createSymbol(source.flags, source.escapedName, ts.getCheckFlags(source) & 8 /* Readonly */);
@@ -82636,6 +82656,22 @@ var ts;
                 }
             });
         }
+        function checkPotentialUncheckedRenamedBindingElementsInTypes() {
+            var _a;
+            for (var _i = 0, potentialUnusedRenamedBindingElementsInTypes_1 = potentialUnusedRenamedBindingElementsInTypes; _i < potentialUnusedRenamedBindingElementsInTypes_1.length; _i++) {
+                var node = potentialUnusedRenamedBindingElementsInTypes_1[_i];
+                if (!((_a = getSymbolOfNode(node)) === null || _a === void 0 ? void 0 : _a.isReferenced)) {
+                    var wrappingDeclaration = ts.walkUpBindingElementsAndPatterns(node);
+                    ts.Debug.assert(ts.isParameterDeclaration(wrappingDeclaration), "Only parameter declaration should be checked here");
+                    var diagnostic = ts.createDiagnosticForNode(node.name, ts.Diagnostics._0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation, ts.declarationNameToString(node.name), ts.declarationNameToString(node.propertyName));
+                    if (!wrappingDeclaration.type) {
+                        // entire parameter does not have type annotation, suggest adding an annotation
+                        ts.addRelatedInfo(diagnostic, ts.createFileDiagnostic(ts.getSourceFileOfNode(wrappingDeclaration), wrappingDeclaration.end, 1, ts.Diagnostics.We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here, ts.declarationNameToString(node.propertyName)));
+                    }
+                    diagnostics.add(diagnostic);
+                }
+            }
+        }
         function bindingNameText(name) {
             switch (name.kind) {
                 case 79 /* Identifier */:
@@ -82937,6 +82973,17 @@ var ts;
                 }
             }
             if (ts.isBindingElement(node)) {
+                if (node.propertyName &&
+                    ts.isIdentifier(node.name) &&
+                    ts.isParameterDeclaration(node) &&
+                    ts.nodeIsMissing(ts.getContainingFunction(node).body)) {
+                    // type F = ({a: string}) => void;
+                    //               ^^^^^^
+                    // variable renaming in function type notation is confusing,
+                    // so we forbid it even if noUnusedLocals is not enabled
+                    potentialUnusedRenamedBindingElementsInTypes.push(node);
+                    return;
+                }
                 if (ts.isObjectBindingPattern(node.parent) && node.dotDotDotToken && languageVersion < 5 /* ES2018 */) {
                     checkExternalEmitHelpers(node, 4 /* Rest */);
                 }
@@ -86400,6 +86447,7 @@ var ts;
                 ts.clear(potentialNewTargetCollisions);
                 ts.clear(potentialWeakMapSetCollisions);
                 ts.clear(potentialReflectCollisions);
+                ts.clear(potentialUnusedRenamedBindingElementsInTypes);
                 ts.forEach(node.statements, checkSourceElement);
                 checkSourceElement(node.endOfFileToken);
                 checkDeferredNodes(node);
@@ -86415,6 +86463,9 @@ var ts;
                             }
                         });
                     }
+                    if (!node.isDeclarationFile) {
+                        checkPotentialUncheckedRenamedBindingElementsInTypes();
+                    }
                 });
                 if (compilerOptions.importsNotUsedAsValues === 2 /* Error */ &&
                     !node.isDeclarationFile &&
@@ -109156,7 +109207,7 @@ var ts;
             });
             return ret;
         }
-        function filterBindingPatternInitializers(name) {
+        function filterBindingPatternInitializersAndRenamings(name) {
             if (name.kind === 79 /* Identifier */) {
                 return name;
             }
@@ -109172,7 +109223,12 @@ var ts;
                 if (elem.kind === 227 /* OmittedExpression */) {
                     return elem;
                 }
-                return factory.updateBindingElement(elem, elem.dotDotDotToken, elem.propertyName, filterBindingPatternInitializers(elem.name), shouldPrintWithInitializer(elem) ? elem.initializer : undefined);
+                if (elem.propertyName && ts.isIdentifier(elem.propertyName) && ts.isIdentifier(elem.name) && !elem.symbol.isReferenced) {
+                    // Unnecessary property renaming is forbidden in types, so remove renaming
+                    return factory.updateBindingElement(elem, elem.dotDotDotToken, 
+                    /* propertyName */ undefined, elem.propertyName, shouldPrintWithInitializer(elem) ? elem.initializer : undefined);
+                }
+                return factory.updateBindingElement(elem, elem.dotDotDotToken, elem.propertyName, filterBindingPatternInitializersAndRenamings(elem.name), shouldPrintWithInitializer(elem) ? elem.initializer : undefined);
             }
         }
         function ensureParameter(p, modifierMask, type) {
@@ -109181,7 +109237,7 @@ var ts;
                 oldDiag = getSymbolAccessibilityDiagnostic;
                 getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(p);
             }
-            var newParam = factory.updateParameterDeclaration(p, maskModifiers(p, modifierMask), p.dotDotDotToken, filterBindingPatternInitializers(p.name), resolver.isOptionalParameter(p) ? (p.questionToken || factory.createToken(57 /* QuestionToken */)) : undefined, ensureType(p, type || p.type, /*ignorePrivate*/ true), // Ignore private param props, since this type is going straight back into a param
+            var newParam = factory.updateParameterDeclaration(p, maskModifiers(p, modifierMask), p.dotDotDotToken, filterBindingPatternInitializersAndRenamings(p.name), resolver.isOptionalParameter(p) ? (p.questionToken || factory.createToken(57 /* QuestionToken */)) : undefined, ensureType(p, type || p.type, /*ignorePrivate*/ true), // Ignore private param props, since this type is going straight back into a param
             ensureNoInitializer(p));
             if (!suppressNewDiagnosticContexts) {
                 getSymbolAccessibilityDiagnostic = oldDiag;
@@ -117324,6 +117380,7 @@ var ts;
         ts.Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations.code,
         ts.Diagnostics.Class_constructor_may_not_be_a_generator.code,
         ts.Diagnostics.Class_constructor_may_not_be_an_accessor.code,
+        ts.Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
     ]);
     /**
      * Determine if source file needs to be re-created even if its text hasn't changed
@@ -122458,9 +122515,11 @@ var ts;
         }
         function watchAffectingLocationsOfResolution(resolution, addToResolutionsWithOnlyAffectingLocations) {
             ts.Debug.assert(!!resolution.refCount);
+            var affectingLocations = resolution.affectingLocations;
+            if (!affectingLocations.length)
+                return;
             if (addToResolutionsWithOnlyAffectingLocations)
                 resolutionsWithOnlyAffectingLocations.push(resolution);
-            var affectingLocations = resolution.affectingLocations;
             // Watch package json
             for (var _i = 0, affectingLocations_1 = affectingLocations; _i < affectingLocations_1.length; _i++) {
                 var affectingLocation = affectingLocations_1[_i];
@@ -170394,6 +170453,38 @@ var ts;
                 }
                 return result.module;
             };
+            /*@internal*/
+            Project.importServicePluginAsync = function (moduleName, initialDir, host, log, logErrors) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var resolvedPath, result, e_1, err;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                ts.Debug.assertIsDefined(host.importServicePlugin);
+                                resolvedPath = ts.combinePaths(initialDir, "node_modules");
+                                log("Dynamically importing " + moduleName + " from " + initialDir + " (resolved to " + resolvedPath + ")");
+                                _a.label = 1;
+                            case 1:
+                                _a.trys.push([1, 3, , 4]);
+                                return [4 /*yield*/, host.importServicePlugin(resolvedPath, moduleName)];
+                            case 2:
+                                result = _a.sent();
+                                return [3 /*break*/, 4];
+                            case 3:
+                                e_1 = _a.sent();
+                                result = { module: undefined, error: e_1 };
+                                return [3 /*break*/, 4];
+                            case 4:
+                                if (result.error) {
+                                    err = result.error.stack || result.error.message || JSON.stringify(result.error);
+                                    (logErrors || log)("Failed to dynamically import module '" + moduleName + "' from " + resolvedPath + ": " + err);
+                                    return [2 /*return*/, undefined];
+                                }
+                                return [2 /*return*/, result.module];
+                        }
+                    });
+                });
+            };
             Project.prototype.isKnownTypesPackageName = function (name) {
                 return this.typingsCache.isKnownTypesPackageName(name);
             };
@@ -171454,7 +171545,7 @@ var ts;
             };
             Project.prototype.enableGlobalPlugins = function (options, pluginConfigOverrides) {
                 var host = this.projectService.host;
-                if (!host.require) {
+                if (!host.require && !host.importServicePlugin) {
                     this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded");
                     return;
                 }
@@ -171483,21 +171574,66 @@ var ts;
                     }
                 }
             };
-            Project.prototype.enablePlugin = function (pluginConfigEntry, searchPaths, pluginConfigOverrides) {
+            /**
+             * Performs the initial steps of enabling a plugin by finding and instantiating the module for a plugin synchronously using 'require'.
+             */
+            /*@internal*/
+            Project.prototype.beginEnablePluginSync = function (pluginConfigEntry, searchPaths, pluginConfigOverrides) {
                 var _this = this;
-                this.projectService.logger.info("Enabling plugin " + pluginConfigEntry.name + " from candidate paths: " + searchPaths.join(","));
-                if (!pluginConfigEntry.name || ts.parsePackageName(pluginConfigEntry.name).rest) {
-                    this.projectService.logger.info("Skipped loading plugin " + (pluginConfigEntry.name || JSON.stringify(pluginConfigEntry)) + " because only package name is allowed plugin name");
-                    return;
-                }
-                var log = function (message) { return _this.projectService.logger.info(message); };
+                ts.Debug.assertIsDefined(this.projectService.host.require);
                 var errorLogs;
+                var log = function (message) { return _this.projectService.logger.info(message); };
                 var logError = function (message) {
-                    (errorLogs || (errorLogs = [])).push(message);
+                    (errorLogs !== null && errorLogs !== void 0 ? errorLogs : (errorLogs = [])).push(message);
                 };
                 var resolvedModule = ts.firstDefined(searchPaths, function (searchPath) {
                     return Project.resolveModule(pluginConfigEntry.name, searchPath, _this.projectService.host, log, logError);
                 });
+                return { pluginConfigEntry: pluginConfigEntry, pluginConfigOverrides: pluginConfigOverrides, resolvedModule: resolvedModule, errorLogs: errorLogs };
+            };
+            /**
+             * Performs the initial steps of enabling a plugin by finding and instantiating the module for a plugin asynchronously using dynamic `import`.
+             */
+            /*@internal*/
+            Project.prototype.beginEnablePluginAsync = function (pluginConfigEntry, searchPaths, pluginConfigOverrides) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var errorLogs, log, logError, resolvedModule, _i, searchPaths_1, searchPath;
+                    var _this = this;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                ts.Debug.assertIsDefined(this.projectService.host.importServicePlugin);
+                                log = function (message) { return _this.projectService.logger.info(message); };
+                                logError = function (message) {
+                                    (errorLogs !== null && errorLogs !== void 0 ? errorLogs : (errorLogs = [])).push(message);
+                                };
+                                _i = 0, searchPaths_1 = searchPaths;
+                                _a.label = 1;
+                            case 1:
+                                if (!(_i < searchPaths_1.length)) return [3 /*break*/, 4];
+                                searchPath = searchPaths_1[_i];
+                                return [4 /*yield*/, Project.importServicePluginAsync(pluginConfigEntry.name, searchPath, this.projectService.host, log, logError)];
+                            case 2:
+                                resolvedModule = (_a.sent());
+                                if (resolvedModule !== undefined) {
+                                    return [3 /*break*/, 4];
+                                }
+                                _a.label = 3;
+                            case 3:
+                                _i++;
+                                return [3 /*break*/, 1];
+                            case 4: return [2 /*return*/, { pluginConfigEntry: pluginConfigEntry, pluginConfigOverrides: pluginConfigOverrides, resolvedModule: resolvedModule, errorLogs: errorLogs }];
+                        }
+                    });
+                });
+            };
+            /**
+             * Performs the remaining steps of enabling a plugin after its module has been instantiated.
+             */
+            /*@internal*/
+            Project.prototype.endEnablePlugin = function (_a) {
+                var _this = this;
+                var pluginConfigEntry = _a.pluginConfigEntry, pluginConfigOverrides = _a.pluginConfigOverrides, resolvedModule = _a.resolvedModule, errorLogs = _a.errorLogs;
                 if (resolvedModule) {
                     var configurationOverride = pluginConfigOverrides && pluginConfigOverrides.get(pluginConfigEntry.name);
                     if (configurationOverride) {
@@ -171509,10 +171645,13 @@ var ts;
                     this.enableProxy(resolvedModule, pluginConfigEntry);
                 }
                 else {
-                    ts.forEach(errorLogs, log);
+                    ts.forEach(errorLogs, function (message) { return _this.projectService.logger.info(message); });
                     this.projectService.logger.info("Couldn't find " + pluginConfigEntry.name);
                 }
             };
+            Project.prototype.enablePlugin = function (pluginConfigEntry, searchPaths, pluginConfigOverrides) {
+                this.projectService.requestEnablePlugin(this, pluginConfigEntry, searchPaths, pluginConfigOverrides);
+            };
             Project.prototype.enableProxy = function (pluginModuleFactory, configEntry) {
                 try {
                     if (typeof pluginModuleFactory !== "function") {
@@ -172164,7 +172303,7 @@ var ts;
             /*@internal*/
             ConfiguredProject.prototype.enablePluginsWithOptions = function (options, pluginConfigOverrides) {
                 var host = this.projectService.host;
-                if (!host.require) {
+                if (!host.require && !host.importServicePlugin) {
                     this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded");
                     return;
                 }
@@ -172183,7 +172322,7 @@ var ts;
                         this.enablePlugin(pluginConfigEntry, searchPaths, pluginConfigOverrides);
                     }
                 }
-                this.enableGlobalPlugins(options, pluginConfigOverrides);
+                return this.enableGlobalPlugins(options, pluginConfigOverrides);
             };
             /**
              * Get the errors that dont have any file name associated
@@ -175605,6 +175744,147 @@ var ts;
                 }
                 return false;
             };
+            /*@internal*/
+            ProjectService.prototype.requestEnablePlugin = function (project, pluginConfigEntry, searchPaths, pluginConfigOverrides) {
+                var _a;
+                if (!this.host.importServicePlugin && !this.host.require) {
+                    this.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded");
+                    return;
+                }
+                this.logger.info("Enabling plugin " + pluginConfigEntry.name + " from candidate paths: " + searchPaths.join(","));
+                if (!pluginConfigEntry.name || ts.parsePackageName(pluginConfigEntry.name).rest) {
+                    this.logger.info("Skipped loading plugin " + (pluginConfigEntry.name || JSON.stringify(pluginConfigEntry)) + " because only package name is allowed plugin name");
+                    return;
+                }
+                // If the host supports dynamic import, begin enabling the plugin asynchronously.
+                if (this.host.importServicePlugin) {
+                    var importPromise = project.beginEnablePluginAsync(pluginConfigEntry, searchPaths, pluginConfigOverrides);
+                    (_a = this.pendingPluginEnablements) !== null && _a !== void 0 ? _a : (this.pendingPluginEnablements = new ts.Map());
+                    var promises = this.pendingPluginEnablements.get(project);
+                    if (!promises)
+                        this.pendingPluginEnablements.set(project, promises = []);
+                    promises.push(importPromise);
+                    return;
+                }
+                // Otherwise, load the plugin using `require`
+                project.endEnablePlugin(project.beginEnablePluginSync(pluginConfigEntry, searchPaths, pluginConfigOverrides));
+            };
+            /* @internal */
+            ProjectService.prototype.hasNewPluginEnablementRequests = function () {
+                return !!this.pendingPluginEnablements;
+            };
+            /* @internal */
+            ProjectService.prototype.hasPendingPluginEnablements = function () {
+                return !!this.currentPluginEnablementPromise;
+            };
+            /**
+             * Waits for any ongoing plugin enablement requests to complete.
+             */
+            /* @internal */
+            ProjectService.prototype.waitForPendingPlugins = function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (!this.currentPluginEnablementPromise) return [3 /*break*/, 2];
+                                return [4 /*yield*/, this.currentPluginEnablementPromise];
+                            case 1:
+                                _a.sent();
+                                return [3 /*break*/, 0];
+                            case 2: return [2 /*return*/];
+                        }
+                    });
+                });
+            };
+            /**
+             * Starts enabling any requested plugins without waiting for the result.
+             */
+            /* @internal */
+            ProjectService.prototype.enableRequestedPlugins = function () {
+                if (this.pendingPluginEnablements) {
+                    void this.enableRequestedPluginsAsync();
+                }
+            };
+            ProjectService.prototype.enableRequestedPluginsAsync = function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    var entries;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (!this.currentPluginEnablementPromise) return [3 /*break*/, 2];
+                                // If we're already enabling plugins, wait for any existing operations to complete
+                                return [4 /*yield*/, this.waitForPendingPlugins()];
+                            case 1:
+                                // If we're already enabling plugins, wait for any existing operations to complete
+                                _a.sent();
+                                _a.label = 2;
+                            case 2:
+                                // Skip if there are no new plugin enablement requests
+                                if (!this.pendingPluginEnablements) {
+                                    return [2 /*return*/];
+                                }
+                                entries = ts.arrayFrom(this.pendingPluginEnablements.entries());
+                                this.pendingPluginEnablements = undefined;
+                                // Start processing the requests, keeping track of the promise for the operation so that
+                                // project consumers can potentially wait for the plugins to load.
+                                this.currentPluginEnablementPromise = this.enableRequestedPluginsWorker(entries);
+                                return [4 /*yield*/, this.currentPluginEnablementPromise];
+                            case 3:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                });
+            };
+            ProjectService.prototype.enableRequestedPluginsWorker = function (pendingPlugins) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var _this = this;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                // This should only be called from `enableRequestedPluginsAsync`, which ensures this precondition is met.
+                                ts.Debug.assert(this.currentPluginEnablementPromise === undefined);
+                                // Process all pending plugins, partitioned by project. This way a project with few plugins doesn't need to wait
+                                // on a project with many plugins.
+                                return [4 /*yield*/, Promise.all(ts.map(pendingPlugins, function (_a) {
+                                        var project = _a[0], promises = _a[1];
+                                        return _this.enableRequestedPluginsForProjectAsync(project, promises);
+                                    }))];
+                            case 1:
+                                // Process all pending plugins, partitioned by project. This way a project with few plugins doesn't need to wait
+                                // on a project with many plugins.
+                                _a.sent();
+                                // Clear the pending operation and notify the client that projects have been updated.
+                                this.currentPluginEnablementPromise = undefined;
+                                this.sendProjectsUpdatedInBackgroundEvent();
+                                return [2 /*return*/];
+                        }
+                    });
+                });
+            };
+            ProjectService.prototype.enableRequestedPluginsForProjectAsync = function (project, promises) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var results, _i, results_1, result;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, Promise.all(promises)];
+                            case 1:
+                                results = _a.sent();
+                                if (project.isClosed()) {
+                                    // project is not alive, so don't enable plugins.
+                                    return [2 /*return*/];
+                                }
+                                for (_i = 0, results_1 = results; _i < results_1.length; _i++) {
+                                    result = results_1[_i];
+                                    project.endEnablePlugin(result);
+                                }
+                                // Plugins may have modified external files, so mark the project as dirty.
+                                this.delayUpdateProjectGraph(project);
+                                return [2 /*return*/];
+                        }
+                    });
+                });
+            };
             ProjectService.prototype.configurePlugin = function (args) {
                 // For any projects that already have the plugin loaded, configure the plugin
                 this.forEachEnabledProject(function (project) { return project.onPluginConfigurationChanged(args.pluginName, args.configuration); });
@@ -176433,7 +176713,6 @@ var ts;
             server.CommandNames.OrganizeImportsFull,
             server.CommandNames.GetEditsForFileRename,
             server.CommandNames.GetEditsForFileRenameFull,
-            server.CommandNames.ConfigurePlugin,
             server.CommandNames.PrepareCallHierarchy,
             server.CommandNames.ProvideCallHierarchyIncomingCalls,
             server.CommandNames.ProvideCallHierarchyOutgoingCalls,
@@ -178701,7 +178980,9 @@ var ts;
             Session.prototype.executeCommand = function (request) {
                 var handler = this.handlers.get(request.command);
                 if (handler) {
-                    return this.executeWithRequestId(request.seq, function () { return handler(request); });
+                    var response = this.executeWithRequestId(request.seq, function () { return handler(request); });
+                    this.projectService.enableRequestedPlugins();
+                    return response;
                 }
                 else {
                     this.logger.msg("Unrecognized JSON command:" + server.stringifyIndented(request), server.Msg.Err);
@@ -179615,6 +179896,8 @@ var ts;
     })(server = ts.server || (ts.server = {}));
 })(ts || (ts = {}));
 /*@internal*/
+/// <reference lib="dom" />
+/// <reference lib="webworker.importscripts" />
 var ts;
 (function (ts) {
     var server;
@@ -179720,11 +180003,31 @@ var ts;
             return MainProcessLogger;
         }(BaseLogger));
         server.MainProcessLogger = MainProcessLogger;
+        // Attempt to load `dynamicImport`
+        if (typeof importScripts === "function") {
+            try {
+                // NOTE: importScripts is synchronous
+                importScripts("dynamicImportCompat.js");
+            }
+            catch (_a) {
+                // ignored
+            }
+        }
         function createWebSystem(host, args, getExecutingFilePath) {
+            var _this = this;
             var returnEmptyString = function () { return ""; };
             var getExecutingDirectoryPath = ts.memoize(function () { return ts.memoize(function () { return ts.ensureTrailingDirectorySeparator(ts.getDirectoryPath(getExecutingFilePath())); }); });
             // Later we could map ^memfs:/ to do something special if we want to enable more functionality like module resolution or something like that
             var getWebPath = function (path) { return ts.startsWith(path, ts.directorySeparator) ? path.replace(ts.directorySeparator, getExecutingDirectoryPath()) : undefined; };
+            var dynamicImport = function (id) { return __awaiter(_this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    // Use syntactic dynamic import first, if available
+                    if (server.dynamicImport) {
+                        return [2 /*return*/, server.dynamicImport(id)];
+                    }
+                    throw new Error("Dynamic import not implemented");
+                });
+            }); };
             return {
                 args: args,
                 newLine: "\r\n",
@@ -179750,7 +180053,45 @@ var ts;
                 setImmediate: function (x) { return setTimeout(x, 0); },
                 clearImmediate: function (handle) { return clearTimeout(handle); },
                 /* eslint-enable no-restricted-globals */
-                require: function () { return ({ module: undefined, error: new Error("Not implemented") }); },
+                importServicePlugin: function (initialDir, moduleName) { return __awaiter(_this, void 0, void 0, function () {
+                    var packageRoot, packageJson, packageJsonResponse, e_1, browser, scriptPath, module_1, e_2;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                packageRoot = ts.combinePaths(initialDir, moduleName);
+                                _a.label = 1;
+                            case 1:
+                                _a.trys.push([1, 4, , 5]);
+                                return [4 /*yield*/, fetch(ts.combinePaths(packageRoot, "package.json"))];
+                            case 2:
+                                packageJsonResponse = _a.sent();
+                                return [4 /*yield*/, packageJsonResponse.json()];
+                            case 3:
+                                packageJson = _a.sent();
+                                return [3 /*break*/, 5];
+                            case 4:
+                                e_1 = _a.sent();
+                                return [2 /*return*/, { module: undefined, error: new Error("Could not load plugin. Could not load 'package.json'.") }];
+                            case 5:
+                                browser = packageJson.browser;
+                                if (!browser) {
+                                    return [2 /*return*/, { module: undefined, error: new Error("Could not load plugin. No 'browser' field found in package.json.") }];
+                                }
+                                scriptPath = ts.combinePaths(packageRoot, browser);
+                                _a.label = 6;
+                            case 6:
+                                _a.trys.push([6, 8, , 9]);
+                                return [4 /*yield*/, dynamicImport(scriptPath)];
+                            case 7:
+                                module_1 = (_a.sent()).default;
+                                return [2 /*return*/, { module: module_1, error: undefined }];
+                            case 8:
+                                e_2 = _a.sent();
+                                return [2 /*return*/, { module: undefined, error: e_2 }];
+                            case 9: return [2 /*return*/];
+                        }
+                    });
+                }); },
                 exit: ts.notImplemented,
                 // Debugging related
                 getEnvironmentVariable: returnEmptyString,