@codingame/monaco-vscode-extensions-service-override 11.1.1 → 12.0.0

package/vscode/src/vs/workbench/services/extensions/common/abstractExtensionService.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Barrier } from 'vscode/vscode/vs/base/common/async';
 import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
@@ -13,6 +14,7 @@ import { isDefined } from 'vscode/vscode/vs/base/common/types';
 import { localize } from 'vscode/vscode/vs/nls';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+import { InstallOperation } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
 import { ImplicitActivationEvents } from 'vscode/vscode/vs/platform/extensionManagement/common/implicitActivationEvents';
 import { ExtensionIdentifierMap, ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
@@ -34,24 +36,26 @@ import { Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagem
 import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service';
 import { LockableExtensionDescriptionRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionDescriptionRegistry';
 import { parseExtensionDevOptions } from './extensionDevOptions.js';
+import { ExtensionRunningPreference, ExtensionHostKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';
 import { ExtensionHostManager } from './extensionHostManager.js';
 import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service';
-import { RemoteRunningLocation, LocalProcessRunningLocation, LocalWebWorkerRunningLocation } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionRunningLocation';
+import { RemoteRunningLocation, LocalProcessRunningLocation, LocalWebWorkerRunningLocation } from '@codingame/monaco-vscode-d7f659f5-da33-5ea8-a3b8-9b94f2cf5f33-common/vscode/vs/workbench/services/extensions/common/extensionRunningLocation';
 import { ExtensionRunningLocationTracker, filterExtensionIdentifiers } from './extensionRunningLocationTracker.js';
-import { toExtensionDescription, ExtensionPointContribution, ActivationTimes, toExtension } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { toExtensionDescription, ExtensionHostStartup, ActivationKind, ExtensionPointContribution, ActivationTimes, toExtension } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { ExtensionsRegistry, ExtensionMessageCollector } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
 import { LazyCreateExtensionHostManager } from './lazyCreateExtensionHostManager.js';
+import { ResponsiveState } from 'vscode/vscode/vs/workbench/services/extensions/common/rpcProtocol';
 import { checkGlobFileExists, checkActivateWorkspaceContainsExtension } from 'vscode/vscode/vs/workbench/services/extensions/common/workspaceContains';
 import { WillShutdownJoinerOrder } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import Severity from 'vscode/vscode/vs/base/common/severity';
 
 var AbstractExtensionService_1;
 const hasOwnProperty = Object.hasOwnProperty;
 const NO_OP_VOID_PROMISE = Promise.resolve(undefined);
 let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtensionService extends Disposable {
-    constructor(_extensionsProposedApi, _extensionHostFactory, _extensionHostKindPicker, _instantiationService, _notificationService, _environmentService, _telemetryService, _extensionEnablementService, _fileService, _productService, _extensionManagementService, _contextService, _configurationService, _extensionManifestPropertiesService, _logService, _remoteAgentService, _remoteExtensionsScannerService, _lifecycleService, _remoteAuthorityResolverService, _dialogService) {
+    constructor(options, _extensionsProposedApi, _extensionHostFactory, _extensionHostKindPicker, _instantiationService, _notificationService, _environmentService, _telemetryService, _extensionEnablementService, _fileService, _productService, _extensionManagementService, _contextService, _configurationService, _extensionManifestPropertiesService, _logService, _remoteAgentService, _remoteExtensionsScannerService, _lifecycleService, _remoteAuthorityResolverService, _dialogService) {
         super();
         this._extensionsProposedApi = _extensionsProposedApi;
         this._extensionHostFactory = _extensionHostFactory;
@@ -73,41 +77,43 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         this._lifecycleService = _lifecycleService;
         this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
         this._dialogService = _dialogService;
-        this._onDidRegisterExtensions = this._register(( (new Emitter())));
+        this._onDidRegisterExtensions = this._register(( new Emitter()));
         this.onDidRegisterExtensions = this._onDidRegisterExtensions.event;
-        this._onDidChangeExtensionsStatus = this._register(( (new Emitter())));
+        this._onDidChangeExtensionsStatus = this._register(( new Emitter()));
         this.onDidChangeExtensionsStatus = this._onDidChangeExtensionsStatus.event;
-        this._onDidChangeExtensions = this._register(( (new Emitter({ leakWarningThreshold: 400 }))));
+        this._onDidChangeExtensions = this._register(( new Emitter({ leakWarningThreshold: 400 })));
         this.onDidChangeExtensions = this._onDidChangeExtensions.event;
-        this._onWillActivateByEvent = this._register(( (new Emitter())));
+        this._onWillActivateByEvent = this._register(( new Emitter()));
         this.onWillActivateByEvent = this._onWillActivateByEvent.event;
-        this._onDidChangeResponsiveChange = this._register(( (new Emitter())));
+        this._onDidChangeResponsiveChange = this._register(( new Emitter()));
         this.onDidChangeResponsiveChange = this._onDidChangeResponsiveChange.event;
-        this._onWillStop = this._register(( (new Emitter())));
+        this._onWillStop = this._register(( new Emitter()));
         this.onWillStop = this._onWillStop.event;
-        this._activationEventReader = ( (new ImplicitActivationAwareReader()));
-        this._registry = ( (new LockableExtensionDescriptionRegistry(this._activationEventReader)));
-        this._installedExtensionsReady = ( (new Barrier()));
-        this._extensionStatus = ( (new ExtensionIdentifierMap()));
-        this._allRequestedActivateEvents = ( (new Set()));
-        this._remoteCrashTracker = ( (new ExtensionHostCrashTracker()));
+        this._activationEventReader = ( new ImplicitActivationAwareReader());
+        this._registry = ( new LockableExtensionDescriptionRegistry(this._activationEventReader));
+        this._installedExtensionsReady = ( new Barrier());
+        this._extensionStatus = ( new ExtensionIdentifierMap());
+        this._allRequestedActivateEvents = ( new Set());
+        this._remoteCrashTracker = ( new ExtensionHostCrashTracker());
         this._deltaExtensionsQueue = [];
         this._inHandleDeltaExtensions = false;
-        this._extensionHostManagers = this._register(( (new ExtensionHostCollection())));
+        this._extensionHostManagers = this._register(( new ExtensionHostCollection()));
         this._resolveAuthorityAttempt = 0;
+        this._hasLocalProcess = options.hasLocalProcess;
+        this._allowRemoteExtensionsInLocalWebWorker = options.allowRemoteExtensionsInLocalWebWorker;
         this._register(this._fileService.onWillActivateFileSystemProvider(e => {
             if (e.scheme !== Schemas.vscodeRemote) {
                 e.join(this.activateByEvent(`onFileSystem:${e.scheme}`));
             }
         }));
-        this._runningLocations = ( (new ExtensionRunningLocationTracker(
+        this._runningLocations = ( new ExtensionRunningLocationTracker(
             this._registry,
             this._extensionHostKindPicker,
             this._environmentService,
             this._configurationService,
             this._logService,
             this._extensionManifestPropertiesService
-        )));
+        ));
         this._register(this._extensionEnablementService.onEnablementChanged((extensions) => {
             const toAdd = [];
             const toRemove = [];
@@ -120,16 +126,16 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 }
             }
             if (isCI) {
-                this._logService.info(`AbstractExtensionService.onEnablementChanged fired for ${( (extensions.map(e => e.identifier.id))).join(', ')}`);
+                this._logService.info(`AbstractExtensionService.onEnablementChanged fired for ${( extensions.map(e => e.identifier.id)).join(', ')}`);
             }
-            this._handleDeltaExtensions(( (new DeltaExtensionsQueueItem(toAdd, toRemove))));
+            this._handleDeltaExtensions(( new DeltaExtensionsQueueItem(toAdd, toRemove)));
         }));
         this._register(this._extensionManagementService.onDidChangeProfile(({ added, removed }) => {
             if (added.length || removed.length) {
                 if (isCI) {
                     this._logService.info(`AbstractExtensionService.onDidChangeProfile fired`);
                 }
-                this._handleDeltaExtensions(( (new DeltaExtensionsQueueItem(added, removed))));
+                this._handleDeltaExtensions(( new DeltaExtensionsQueueItem(added, removed)));
             }
         }));
         this._register(this._extensionManagementService.onDidEnableExtensions(extensions => {
@@ -137,21 +143,21 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 if (isCI) {
                     this._logService.info(`AbstractExtensionService.onDidEnableExtensions fired`);
                 }
-                this._handleDeltaExtensions(( (new DeltaExtensionsQueueItem(extensions, []))));
+                this._handleDeltaExtensions(( new DeltaExtensionsQueueItem(extensions, [])));
             }
         }));
         this._register(this._extensionManagementService.onDidInstallExtensions((result) => {
             const extensions = [];
             for (const { local, operation } of result) {
-                if (local && local.isValid && operation !== 4  && this._safeInvokeIsEnabled(local)) {
+                if (local && local.isValid && operation !== InstallOperation.Migrate && this._safeInvokeIsEnabled(local)) {
                     extensions.push(local);
                 }
             }
             if (extensions.length) {
                 if (isCI) {
-                    this._logService.info(`AbstractExtensionService.onDidInstallExtensions fired for ${( (extensions.map(e => e.identifier.id))).join(', ')}`);
+                    this._logService.info(`AbstractExtensionService.onDidInstallExtensions fired for ${( extensions.map(e => e.identifier.id)).join(', ')}`);
                 }
-                this._handleDeltaExtensions(( (new DeltaExtensionsQueueItem(extensions, []))));
+                this._handleDeltaExtensions(( new DeltaExtensionsQueueItem(extensions, [])));
             }
         }));
         this._register(this._extensionManagementService.onDidUninstallExtension((event) => {
@@ -159,7 +165,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 if (isCI) {
                     this._logService.info(`AbstractExtensionService.onDidUninstallExtension fired for ${event.identifier.id}`);
                 }
-                this._handleDeltaExtensions(( (new DeltaExtensionsQueueItem([], [event.identifier.id]))));
+                this._handleDeltaExtensions(( new DeltaExtensionsQueueItem([], [event.identifier.id])));
             }
         }));
         this._register(this._lifecycleService.onWillShutdown(event => {
@@ -175,14 +181,14 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                     }
                 }, {
                     id: 'join.disconnectRemote',
-                    label: ( localize(1307, "Disconnect Remote Agent")),
+                    label: ( localize(11473, "Disconnect Remote Agent")),
                     order: WillShutdownJoinerOrder.Last
                 });
             }
             else {
                 event.join(this._doStopExtensionHosts(), {
                     id: 'join.stopExtensionHosts',
-                    label: ( localize(1308, "Stopping Extension Hosts")),
+                    label: ( localize(11474, "Stopping Extension Hosts")),
                 });
             }
         }));
@@ -212,7 +218,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     }
     async _deltaExtensions(lock, _toAdd, _toRemove) {
         if (isCI) {
-            this._logService.info(`AbstractExtensionService._deltaExtensions: toAdd: [${( (_toAdd.map(e => e.identifier.id))).join(',')}] toRemove: [${( (_toRemove.map(e => typeof e === 'string' ? e : e.identifier.id))).join(',')}]`);
+            this._logService.info(`AbstractExtensionService._deltaExtensions: toAdd: [${( _toAdd.map(e => e.identifier.id)).join(',')}] toRemove: [${( _toRemove.map(e => typeof e === 'string' ? e : e.identifier.id)).join(',')}]`);
         }
         let toRemove = [];
         for (let i = 0, len = _toRemove.length; i < len; i++) {
@@ -246,31 +252,31 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         if (toAdd.length === 0 && toRemove.length === 0) {
             return;
         }
-        const result = this._registry.deltaExtensions(lock, toAdd, ( (toRemove.map(e => e.identifier))));
+        const result = this._registry.deltaExtensions(lock, toAdd, ( toRemove.map(e => e.identifier)));
         this._onDidChangeExtensions.fire({ added: toAdd, removed: toRemove });
         toRemove = toRemove.concat(result.removedDueToLooping);
         if (result.removedDueToLooping.length > 0) {
             this._notificationService.notify({
-                severity: Severity$1.Error,
+                severity: Severity.Error,
                 message: ( localize(
-                    1309,
+                    11475,
                     "The following extensions contain dependency loops and have been disabled: {0}",
-                    ( (result.removedDueToLooping.map(e => `'${e.identifier.value}'`))).join(', ')
+                    ( result.removedDueToLooping.map(e => `'${e.identifier.value}'`)).join(', ')
                 ))
             });
         }
         this._extensionsProposedApi.updateEnabledApiProposals(toAdd);
-        this._doHandleExtensionPoints([].concat(toAdd).concat(toRemove));
-        await this._updateExtensionsOnExtHosts(result.versionId, toAdd, ( (toRemove.map(e => e.identifier))));
+        this._doHandleExtensionPoints([].concat(toAdd).concat(toRemove), false);
+        await this._updateExtensionsOnExtHosts(result.versionId, toAdd, ( toRemove.map(e => e.identifier)));
         for (let i = 0; i < toAdd.length; i++) {
             this._activateAddedExtensionIfNeeded(toAdd[i]);
         }
     }
     async _updateExtensionsOnExtHosts(versionId, toAdd, toRemove) {
         const removedRunningLocation = this._runningLocations.deltaExtensions(toAdd, toRemove);
-        const promises = ( (this._extensionHostManagers.map(
+        const promises = ( this._extensionHostManagers.map(
             extHostManager => this._updateExtensionsOnExtHost(extHostManager, versionId, toAdd, toRemove, removedRunningLocation)
-        )));
+        ));
         await Promise.all(promises);
     }
     async _updateExtensionsOnExtHost(extensionHostManager, versionId, toAdd, toRemove, removedRunningLocation) {
@@ -278,11 +284,11 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         const myToRemove = filterExtensionIdentifiers(toRemove, removedRunningLocation, extRunningLocation => extensionHostManager.representsRunningLocation(extRunningLocation));
         const addActivationEvents = ImplicitActivationEvents.createActivationEventsMap(toAdd);
         if (isCI) {
-            const printExtIds = (extensions) => ( (extensions.map(e => e.identifier.value))).join(',');
-            const printIds = (extensions) => ( (extensions.map(e => e.value))).join(',');
+            const printExtIds = (extensions) => ( extensions.map(e => e.identifier.value)).join(',');
+            const printIds = (extensions) => ( extensions.map(e => e.value)).join(',');
             this._logService.info(`AbstractExtensionService: Calling deltaExtensions: toRemove: [${printIds(toRemove)}], toAdd: [${printExtIds(toAdd)}], myToRemove: [${printIds(myToRemove)}], myToAdd: [${printExtIds(myToAdd)}],`);
         }
-        await extensionHostManager.deltaExtensions({ versionId, toRemove, toAdd, addActivationEvents, myToRemove, myToAdd: ( (myToAdd.map(extension => extension.identifier))) });
+        await extensionHostManager.deltaExtensions({ versionId, toRemove, toAdd, addActivationEvents, myToRemove, myToAdd: ( myToAdd.map(extension => extension.identifier)) });
     }
     canAddExtension(extension) {
         return this._canAddExtension(extension, []);
@@ -290,16 +296,16 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     _canAddExtension(extension, extensionsBeingRemoved) {
         const existing = this._registry.getExtensionDescriptionByIdOrUUID(extension.identifier, extension.id);
         if (existing) {
-            const isBeingRemoved = ( (extensionsBeingRemoved.some(
+            const isBeingRemoved = ( extensionsBeingRemoved.some(
                 (extensionDescription) => ExtensionIdentifier.equals(extension.identifier, extensionDescription.identifier)
-            )));
+            ));
             if (!isBeingRemoved) {
                 return false;
             }
         }
         const extensionKinds = this._runningLocations.readExtensionKinds(extension);
         const isRemote = extension.extensionLocation.scheme === Schemas.vscodeRemote;
-        const extensionHostKind = this._extensionHostKindPicker.pickExtensionHostKind(extension.identifier, extensionKinds, !isRemote, isRemote, 0 );
+        const extensionHostKind = this._extensionHostKindPicker.pickExtensionHostKind(extension.identifier, extensionKinds, !isRemote, isRemote, ExtensionRunningPreference.None);
         if (extensionHostKind === null) {
             return false;
         }
@@ -321,7 +327,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         let hasWorkspaceContains = false;
         const activationEvents = this._activationEventReader.readActivationEvents(extensionDescription);
         for (const activationEvent of activationEvents) {
-            if (( (this._allRequestedActivateEvents.has(activationEvent)))) {
+            if (( this._allRequestedActivateEvents.has(activationEvent))) {
                 shouldActivate = true;
                 shouldActivateReason = activationEvent;
                 break;
@@ -341,16 +347,16 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             }
         }
         if (shouldActivate) {
-            await Promise.all(( (this._extensionHostManagers.map(
+            await Promise.all(( this._extensionHostManagers.map(
                 extHostManager => extHostManager.activate(extensionDescription.identifier, { startup: false, extensionId: extensionDescription.identifier, activationEvent: shouldActivateReason })
-            )))).then(() => { });
+            ))).then(() => { });
         }
         else if (hasWorkspaceContains) {
             const workspace = await this._contextService.getCompleteWorkspace();
             const forceUsingSearch = !!this._environmentService.remoteAuthority;
             const host = {
                 logService: this._logService,
-                folders: ( (workspace.folders.map(folder => folder.uri))),
+                folders: ( workspace.folders.map(folder => folder.uri)),
                 forceUsingSearch: forceUsingSearch,
                 exists: (uri) => this._fileService.exists(uri),
                 checkExists: (folders, includes, token) => this._instantiationService.invokeFunction((accessor) => checkGlobFileExists(accessor, folders, includes, token))
@@ -359,9 +365,9 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             if (!result) {
                 return;
             }
-            await Promise.all(( (this._extensionHostManagers.map(
+            await Promise.all(( this._extensionHostManagers.map(
                 extHostManager => extHostManager.activate(extensionDescription.identifier, { startup: false, extensionId: extensionDescription.identifier, activationEvent: result.activationEvent })
-            )))).then(() => { });
+            ))).then(() => { });
         }
     }
     async _initialize() {
@@ -369,13 +375,12 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         this._startExtensionHostsIfNecessary(true, []);
         const lock = await this._registry.acquireLock('_initialize');
         try {
-            const resolvedExtensions = await this._resolveExtensions();
-            this._processExtensions(lock, resolvedExtensions);
+            await this._resolveAndProcessExtensions(lock);
             const snapshot = this._registry.getSnapshot();
             for (const extHostManager of this._extensionHostManagers) {
-                if (extHostManager.startup !== 1 ) {
+                if (extHostManager.startup !== ExtensionHostStartup.EagerAutoStart) {
                     const extensions = this._runningLocations.filterByExtensionHostManager(snapshot.extensions, extHostManager);
-                    extHostManager.start(snapshot.versionId, snapshot.extensions, ( (extensions.map(extension => extension.identifier))));
+                    extHostManager.start(snapshot.versionId, snapshot.extensions, ( extensions.map(extension => extension.identifier)));
                 }
             }
         }
@@ -386,34 +391,62 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         mark('code/didLoadExtensions');
         await this._handleExtensionTests();
     }
-    _processExtensions(lock, resolvedExtensions) {
-        const { allowRemoteExtensionsInLocalWebWorker, hasLocalProcess } = resolvedExtensions;
-        const localExtensions = checkEnabledAndProposedAPI(this._logService, this._extensionEnablementService, this._extensionsProposedApi, resolvedExtensions.local, false);
-        let remoteExtensions = checkEnabledAndProposedAPI(this._logService, this._extensionEnablementService, this._extensionsProposedApi, resolvedExtensions.remote, false);
+    async _resolveAndProcessExtensions(lock) {
+        let resolverExtensions = [];
+        let localExtensions = [];
+        let remoteExtensions = [];
+        for await (const extensions of this._resolveExtensions()) {
+            if (extensions instanceof ResolverExtensions) {
+                resolverExtensions = checkEnabledAndProposedAPI(this._logService, this._extensionEnablementService, this._extensionsProposedApi, extensions.extensions, false);
+                this._registry.deltaExtensions(lock, resolverExtensions, []);
+                this._doHandleExtensionPoints(resolverExtensions, true);
+            }
+            if (extensions instanceof LocalExtensions) {
+                localExtensions = checkEnabledAndProposedAPI(this._logService, this._extensionEnablementService, this._extensionsProposedApi, extensions.extensions, false);
+            }
+            if (extensions instanceof RemoteExtensions) {
+                remoteExtensions = checkEnabledAndProposedAPI(this._logService, this._extensionEnablementService, this._extensionsProposedApi, extensions.extensions, false);
+            }
+        }
         this._runningLocations.initializeRunningLocation(localExtensions, remoteExtensions);
         this._startExtensionHostsIfNecessary(true, []);
-        const remoteExtensionsThatNeedToRunLocally = (allowRemoteExtensionsInLocalWebWorker ? this._runningLocations.filterByExtensionHostKind(remoteExtensions, 2 ) : []);
-        const localProcessExtensions = (hasLocalProcess ? this._runningLocations.filterByExtensionHostKind(localExtensions, 1 ) : []);
-        const localWebWorkerExtensions = this._runningLocations.filterByExtensionHostKind(localExtensions, 2 );
-        remoteExtensions = this._runningLocations.filterByExtensionHostKind(remoteExtensions, 3 );
+        const remoteExtensionsThatNeedToRunLocally = (this._allowRemoteExtensionsInLocalWebWorker ? this._runningLocations.filterByExtensionHostKind(remoteExtensions, ExtensionHostKind.LocalWebWorker) : []);
+        const localProcessExtensions = (this._hasLocalProcess ? this._runningLocations.filterByExtensionHostKind(localExtensions, ExtensionHostKind.LocalProcess) : []);
+        const localWebWorkerExtensions = this._runningLocations.filterByExtensionHostKind(localExtensions, ExtensionHostKind.LocalWebWorker);
+        remoteExtensions = this._runningLocations.filterByExtensionHostKind(remoteExtensions, ExtensionHostKind.Remote);
         for (const ext of remoteExtensionsThatNeedToRunLocally) {
             if (!includes(localWebWorkerExtensions, ext.identifier)) {
                 localWebWorkerExtensions.push(ext);
             }
         }
         const allExtensions = remoteExtensions.concat(localProcessExtensions).concat(localWebWorkerExtensions);
-        const result = this._registry.deltaExtensions(lock, allExtensions, []);
+        let toAdd = allExtensions;
+        if (resolverExtensions.length) {
+            toAdd = allExtensions.filter(extension => !( resolverExtensions.some(
+                e => ExtensionIdentifier.equals(e.identifier, extension.identifier) && ( e.extensionLocation.toString()) === ( extension.extensionLocation.toString())
+            )));
+            if (allExtensions.length < toAdd.length + resolverExtensions.length) {
+                const toRemove = resolverExtensions.filter(registered => !( allExtensions.some(
+                    e => ExtensionIdentifier.equals(e.identifier, registered.identifier) && ( e.extensionLocation.toString()) === ( registered.extensionLocation.toString())
+                )));
+                if (toRemove.length) {
+                    this._registry.deltaExtensions(lock, [], ( toRemove.map(e => e.identifier)));
+                    this._doHandleExtensionPoints(toRemove, true);
+                }
+            }
+        }
+        const result = this._registry.deltaExtensions(lock, toAdd, []);
         if (result.removedDueToLooping.length > 0) {
             this._notificationService.notify({
-                severity: Severity$1.Error,
+                severity: Severity.Error,
                 message: ( localize(
-                    1309,
+                    11475,
                     "The following extensions contain dependency loops and have been disabled: {0}",
-                    ( (result.removedDueToLooping.map(e => `'${e.identifier.value}'`))).join(', ')
+                    ( result.removedDueToLooping.map(e => `'${e.identifier.value}'`)).join(', ')
                 ))
             });
         }
-        this._doHandleExtensionPoints(this._registry.getAllExtensionDescriptions());
+        this._doHandleExtensionPoints(this._registry.getAllExtensionDescriptions(), false);
     }
     async _handleExtensionTests() {
         if (!this._environmentService.isExtensionDevelopment || !this._environmentService.extensionTestsLocationURI) {
@@ -422,9 +455,9 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         const extensionHostManager = this.findTestExtensionHost(this._environmentService.extensionTestsLocationURI);
         if (!extensionHostManager) {
             const msg = ( localize(
-                1310,
+                11476,
                 "No extension host found that can launch the test runner at {0}.",
-                 (this._environmentService.extensionTestsLocationURI.toString())
+                (this._environmentService.extensionTestsLocationURI.toString())
             ));
             console.error(msg);
             this._notificationService.error(msg);
@@ -456,10 +489,10 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         }
         if (runningLocation === null) {
             if (testLocation.scheme === Schemas.vscodeRemote) {
-                runningLocation = ( (new RemoteRunningLocation()));
+                runningLocation = ( new RemoteRunningLocation());
             }
             else {
-                runningLocation = ( (new LocalProcessRunningLocation(0)));
+                runningLocation = ( new LocalProcessRunningLocation(0));
             }
         }
         if (runningLocation !== null) {
@@ -470,7 +503,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     _releaseBarrier() {
         this._installedExtensionsReady.open();
         this._onDidRegisterExtensions.fire(undefined);
-        this._onDidChangeExtensionsStatus.fire(( (this._registry.getAllExtensionDescriptions().map(e => e.identifier))));
+        this._onDidChangeExtensionsStatus.fire(( this._registry.getAllExtensionDescriptions().map(e => e.identifier)));
     }
     async _resolveAuthorityInitial(remoteAuthority) {
         const MAX_ATTEMPTS = 5;
@@ -525,12 +558,12 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     async _resolveAuthorityOnExtensionHosts(kind, remoteAuthority) {
         const extensionHosts = this._getExtensionHostManagers(kind);
         if (extensionHosts.length === 0) {
-            throw ( (new Error(`Cannot resolve authority`)));
+            throw ( new Error(`Cannot resolve authority`));
         }
         this._resolveAuthorityAttempt++;
-        const results = await Promise.all(( (extensionHosts.map(
+        const results = await Promise.all(( extensionHosts.map(
             extHost => extHost.resolveAuthority(remoteAuthority, this._resolveAuthorityAttempt)
-        ))));
+        )));
         let bestErrorResult = null;
         for (const result of results) {
             if (result.type === 'ok') {
@@ -546,24 +579,24 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 bestErrorResult = result;
             }
         }
-        throw ( (new RemoteAuthorityResolverError(
+        throw ( new RemoteAuthorityResolverError(
             bestErrorResult.error.message,
             bestErrorResult.error.code,
             bestErrorResult.error.detail
-        )));
+        ));
     }
     stopExtensionHosts(reason, auto) {
         return this._doStopExtensionHostsWithVeto(reason, auto);
     }
     async _doStopExtensionHosts() {
         const previouslyActivatedExtensionIds = [];
-        for (const extensionStatus of ( (this._extensionStatus.values()))) {
+        for (const extensionStatus of ( this._extensionStatus.values())) {
             if (extensionStatus.activationStarted) {
                 previouslyActivatedExtensionIds.push(extensionStatus.id);
             }
         }
         await this._extensionHostManagers.stopAllInReverse();
-        for (const extensionStatus of ( (this._extensionStatus.values()))) {
+        for (const extensionStatus of ( this._extensionStatus.values())) {
             extensionStatus.clearRuntimeStatus();
         }
         if (previouslyActivatedExtensionIds.length > 0) {
@@ -575,7 +608,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             return false;
         }
         const vetos = [];
-        const vetoReasons = ( (new Set()));
+        const vetoReasons = ( new Set());
         this._onWillStop.fire({
             reason,
             auto,
@@ -592,7 +625,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                             vetoReasons.add(reason);
                         }
                     }).catch(error => {
-                        vetoReasons.add(( localize(1311, "{0} (Error: {1})", reason, toErrorMessage(error))));
+                        vetoReasons.add(( localize(11477, "{0} (Error: {1})", reason, toErrorMessage(error))));
                     });
                 }
             }
@@ -605,13 +638,13 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             if (!auto) {
                 const vetoReasonsArray = Array.from(vetoReasons);
                 this._logService.warn(`Extension host was not stopped because of veto (stop reason: ${reason}, veto reason: ${vetoReasonsArray.join(', ')})`);
-                await this._dialogService.warn(( localize(1312, "The following operation was blocked: {0}", reason)), vetoReasonsArray.length === 1 ?
-                    ( localize(1313, "The reason for blocking the operation: {0}", vetoReasonsArray[0])) :
+                await this._dialogService.warn(( localize(11478, "The following operation was blocked: {0}", reason)), vetoReasonsArray.length === 1 ?
+                    ( localize(11479, "The reason for blocking the operation: {0}", vetoReasonsArray[0])) :
                     ( localize(
-                        1314,
-                        "The reasons for blocking the operation:\n- {0}",
-                        vetoReasonsArray.join('\n -')
-                    )));
+                    11480,
+                    "The reasons for blocking the operation:\n- {0}",
+                    vetoReasonsArray.join('\n -')
+                )));
             }
         }
         return !veto;
@@ -619,12 +652,12 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     _startExtensionHostsIfNecessary(isInitialStart, initialActivationEvents) {
         const locations = [];
         for (let affinity = 0; affinity <= this._runningLocations.maxLocalProcessAffinity; affinity++) {
-            locations.push(( (new LocalProcessRunningLocation(affinity))));
+            locations.push(( new LocalProcessRunningLocation(affinity)));
         }
         for (let affinity = 0; affinity <= this._runningLocations.maxLocalWebWorkerAffinity; affinity++) {
-            locations.push(( (new LocalWebWorkerRunningLocation(affinity))));
+            locations.push(( new LocalWebWorkerRunningLocation(affinity)));
         }
-        locations.push(( (new RemoteRunningLocation())));
+        locations.push(( new RemoteRunningLocation()));
         for (const location of locations) {
             if (this._extensionHostManagers.getByRunningLocation(location)) {
                 continue;
@@ -642,13 +675,13 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             return null;
         }
         const processManager = this._doCreateExtensionHostManager(extensionHost, initialActivationEvents);
-        const disposableStore = ( (new DisposableStore()));
+        const disposableStore = ( new DisposableStore());
         disposableStore.add(processManager.onDidExit(([code, signal]) => this._onExtensionHostCrashOrExit(processManager, code, signal)));
         disposableStore.add(processManager.onDidChangeResponsiveState((responsiveState) => {
-            this._logService.info(`Extension host (${processManager.friendyName}) is ${responsiveState === 0  ? 'responsive' : 'unresponsive'}.`);
+            this._logService.info(`Extension host (${processManager.friendyName}) is ${responsiveState === ResponsiveState.Responsive ? 'responsive' : 'unresponsive'}.`);
             this._onDidChangeResponsiveChange.fire({
                 extensionHostKind: processManager.kind,
-                isResponsive: responsiveState === 0 ,
+                isResponsive: responsiveState === ResponsiveState.Responsive,
                 getInspectListener: (tryEnableInspector) => {
                     return processManager.getInspectPort(tryEnableInspector);
                 }
@@ -658,7 +691,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     }
     _doCreateExtensionHostManager(extensionHost, initialActivationEvents) {
         const internalExtensionService = this._acquireInternalAPI(extensionHost);
-        if (extensionHost.startup === 3  && initialActivationEvents.length === 0) {
+        if (extensionHost.startup === ExtensionHostStartup.Lazy && initialActivationEvents.length === 0) {
             return this._instantiationService.createInstance(LazyCreateExtensionHostManager, extensionHost, internalExtensionService);
         }
         return this._instantiationService.createInstance(ExtensionHostManager, extensionHost, initialActivationEvents, internalExtensionService);
@@ -673,10 +706,10 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     }
     _onExtensionHostCrashed(extensionHost, code, signal) {
         console.error(`Extension host (${extensionHost.friendyName}) terminated unexpectedly. Code: ${code}, Signal: ${signal}`);
-        if (extensionHost.kind === 1 ) {
+        if (extensionHost.kind === ExtensionHostKind.LocalProcess) {
             this._doStopExtensionHosts();
         }
-        else if (extensionHost.kind === 3 ) {
+        else if (extensionHost.kind === ExtensionHostKind.Remote) {
             if (signal) {
                 this._onRemoteExtensionHostCrashed(extensionHost, signal);
             }
@@ -684,17 +717,15 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         }
     }
     _getExtensionHostExitInfoWithTimeout(reconnectionToken) {
-        return (
-             (new Promise((resolve, reject) => {
-                const timeoutHandle = setTimeout(() => {
-                    reject(( (new Error('getExtensionHostExitInfo timed out'))));
-                }, 2000);
-                this._remoteAgentService.getExtensionHostExitInfo(reconnectionToken).then((r) => {
-                    clearTimeout(timeoutHandle);
-                    resolve(r);
-                }, reject);
-            }))
-        );
+        return ( new Promise((resolve, reject) => {
+            const timeoutHandle = setTimeout(() => {
+                reject(( new Error('getExtensionHostExitInfo timed out')));
+            }, 2000);
+            this._remoteAgentService.getExtensionHostExitInfo(reconnectionToken).then((r) => {
+                clearTimeout(timeoutHandle);
+                resolve(r);
+            }, reject);
+        }));
     }
     async _onRemoteExtensionHostCrashed(extensionHost, reconnectionToken) {
         try {
@@ -706,17 +737,17 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._remoteCrashTracker.registerCrash();
             if (this._remoteCrashTracker.shouldAutomaticallyRestart()) {
                 this._logService.info(`Automatically restarting the remote extension host.`);
-                this._notificationService.status(( localize(1315, "The remote extension host terminated unexpectedly. Restarting...")), { hideAfter: 5000 });
-                this._startExtensionHostsIfNecessary(false, Array.from(( (this._allRequestedActivateEvents.keys()))));
+                this._notificationService.status(( localize(11481, "The remote extension host terminated unexpectedly. Restarting...")), { hideAfter: 5000 });
+                this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
             }
             else {
-                this._notificationService.prompt(Severity$1.Error, ( localize(
-                    1316,
+                this._notificationService.prompt(Severity.Error, ( localize(
+                    11482,
                     "Remote Extension host terminated unexpectedly 3 times within the last 5 minutes."
                 )), [{
-                        label: ( localize(1317, "Restart Remote Extension Host")),
+                        label: ( localize(11483, "Restart Remote Extension Host")),
                         run: () => {
-                            this._startExtensionHostsIfNecessary(false, Array.from(( (this._allRequestedActivateEvents.keys()))));
+                            this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
                         }
                     }]);
             }
@@ -726,13 +757,13 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     }
     _logExtensionHostCrash(extensionHost) {
         const activatedExtensions = [];
-        for (const extensionStatus of ( (this._extensionStatus.values()))) {
+        for (const extensionStatus of ( this._extensionStatus.values())) {
             if (extensionStatus.activationStarted && extensionHost.containsExtension(extensionStatus.id)) {
                 activatedExtensions.push(extensionStatus.id);
             }
         }
         if (activatedExtensions.length > 0) {
-            this._logService.error(`Extension host (${extensionHost.friendyName}) terminated unexpectedly. The following extensions were running: ${( (activatedExtensions.map(id => id.value))).join(', ')}`);
+            this._logService.error(`Extension host (${extensionHost.friendyName}) terminated unexpectedly. The following extensions were running: ${( activatedExtensions.map(id => id.value)).join(', ')}`);
         }
         else {
             this._logService.error(`Extension host (${extensionHost.friendyName}) terminated unexpectedly. No extensions were activated.`);
@@ -741,19 +772,19 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     async startExtensionHosts(updates) {
         await this._doStopExtensionHosts();
         if (updates) {
-            await this._handleDeltaExtensions(( (new DeltaExtensionsQueueItem(updates.toAdd, updates.toRemove))));
+            await this._handleDeltaExtensions(( new DeltaExtensionsQueueItem(updates.toAdd, updates.toRemove)));
         }
         const lock = await this._registry.acquireLock('startExtensionHosts');
         try {
-            this._startExtensionHostsIfNecessary(false, Array.from(( (this._allRequestedActivateEvents.keys()))));
-            const localProcessExtensionHosts = this._getExtensionHostManagers(1 );
-            await Promise.all(( (localProcessExtensionHosts.map(extHost => extHost.ready()))));
+            this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
+            const localProcessExtensionHosts = this._getExtensionHostManagers(ExtensionHostKind.LocalProcess);
+            await Promise.all(( localProcessExtensionHosts.map(extHost => extHost.ready())));
         }
         finally {
             lock.dispose();
         }
     }
-    activateByEvent(activationEvent, activationKind = 0 ) {
+    activateByEvent(activationEvent, activationKind = ActivationKind.Normal) {
         if (this._installedExtensionsReady.isOpen()) {
             this._allRequestedActivateEvents.add(activationEvent);
             if (!this._registry.containsActivationEvent(activationEvent)) {
@@ -763,16 +794,16 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         }
         else {
             this._allRequestedActivateEvents.add(activationEvent);
-            if (activationKind === 1 ) {
+            if (activationKind === ActivationKind.Immediate) {
                 return this._activateByEvent(activationEvent, activationKind);
             }
             return this._installedExtensionsReady.wait().then(() => this._activateByEvent(activationEvent, activationKind));
         }
     }
     _activateByEvent(activationEvent, activationKind) {
-        const result = Promise.all(( (this._extensionHostManagers.map(
+        const result = Promise.all(( this._extensionHostManagers.map(
             extHostManager => extHostManager.activateByEvent(activationEvent, activationKind)
-        )))).then(() => { });
+        ))).then(() => { });
         this._onWillActivateByEvent.fire({
             event: activationEvent,
             activation: result
@@ -811,7 +842,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             const result = [];
             for (const desc of availableExtensions) {
                 if (desc.contributes && hasOwnProperty.call(desc.contributes, extPoint.name)) {
-                    result.push(( (new ExtensionPointContribution(desc, desc.contributes[extPoint.name]))));
+                    result.push(( new ExtensionPointContribution(desc, desc.contributes[extPoint.name])));
                 }
             }
             return result;
@@ -836,12 +867,12 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         return result;
     }
     async getInspectPorts(extensionHostKind, tryEnableInspector) {
-        const result = await Promise.all(( (this._getExtensionHostManagers(extensionHostKind).map(extHost => extHost.getInspectPort(tryEnableInspector)))));
+        const result = await Promise.all(( this._getExtensionHostManagers(extensionHostKind).map(extHost => extHost.getInspectPort(tryEnableInspector))));
         return result.filter(isDefined);
     }
     async setRemoteEnvironment(env) {
-        await ( (this._extensionHostManagers
-            .map(manager => manager.setRemoteEnvironment(env))));
+        await ( this._extensionHostManagers
+            .map(manager => manager.setRemoteEnvironment(env)));
     }
     _safeInvokeIsEnabled(extension) {
         try {
@@ -851,7 +882,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             return false;
         }
     }
-    _doHandleExtensionPoints(affectedExtensions) {
+    _doHandleExtensionPoints(affectedExtensions, onlyResolverExtensionPoints) {
         const affectedExtensionPoints = Object.create(null);
         for (const extensionDescription of affectedExtensions) {
             if (extensionDescription.contributes) {
@@ -865,19 +896,19 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         const messageHandler = (msg) => this._handleExtensionPointMessage(msg);
         const availableExtensions = this._registry.getAllExtensionDescriptions();
         const extensionPoints = ExtensionsRegistry.getExtensionPoints();
-        mark('code/willHandleExtensionPoints');
+        mark(onlyResolverExtensionPoints ? 'code/willHandleResolverExtensionPoints' : 'code/willHandleExtensionPoints');
         for (const extensionPoint of extensionPoints) {
-            if (affectedExtensionPoints[extensionPoint.name]) {
+            if (affectedExtensionPoints[extensionPoint.name] && (!onlyResolverExtensionPoints || extensionPoint.canHandleResolver)) {
                 mark(`code/willHandleExtensionPoint/${extensionPoint.name}`);
                 AbstractExtensionService_1._handleExtensionPoint(extensionPoint, availableExtensions, messageHandler);
                 mark(`code/didHandleExtensionPoint/${extensionPoint.name}`);
             }
         }
-        mark('code/didHandleExtensionPoints');
+        mark(onlyResolverExtensionPoints ? 'code/didHandleResolverExtensionPoints' : 'code/didHandleExtensionPoints');
     }
     _getOrCreateExtensionStatus(extensionId) {
-        if (!( (this._extensionStatus.has(extensionId)))) {
-            this._extensionStatus.set(extensionId, ( (new ExtensionStatus(extensionId))));
+        if (!( this._extensionStatus.has(extensionId))) {
+            this._extensionStatus.set(extensionId, ( new ExtensionStatus(extensionId)));
         }
         return this._extensionStatus.get(extensionId);
     }
@@ -886,15 +917,15 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         extensionStatus.addMessage(msg);
         const extension = this._registry.getExtensionDescription(msg.extensionId);
         const strMsg = `[${msg.extensionId.value}]: ${msg.message}`;
-        if (msg.type === Severity$1.Error) {
+        if (msg.type === Severity.Error) {
             if (extension && extension.isUnderDevelopment) {
-                this._notificationService.notify({ severity: Severity$1.Error, message: strMsg });
+                this._notificationService.notify({ severity: Severity.Error, message: strMsg });
             }
             this._logService.error(strMsg);
         }
-        else if (msg.type === Severity$1.Warning) {
+        else if (msg.type === Severity.Warning) {
             if (extension && extension.isUnderDevelopment) {
-                this._notificationService.notify({ severity: Severity$1.Warning, message: strMsg });
+                this._notificationService.notify({ severity: Severity.Warning, message: strMsg });
             }
             this._logService.warn(strMsg);
         }
@@ -915,7 +946,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 users.push({
                     description: desc,
                     value: desc.contributes[extensionPoint.name],
-                    collector: ( (new ExtensionMessageCollector(messageHandler, desc, extensionPoint.name)))
+                    collector: ( new ExtensionMessageCollector(messageHandler, desc, extensionPoint.name))
                 });
             }
         }
@@ -941,10 +972,10 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         };
     }
     async _activateById(extensionId, reason) {
-        const results = await Promise.all(( (this._extensionHostManagers.map(manager => manager.activate(extensionId, reason)))));
-        const activated = ( (results.some(e => e)));
+        const results = await Promise.all(( this._extensionHostManagers.map(manager => manager.activate(extensionId, reason))));
+        const activated = ( results.some(e => e));
         if (!activated) {
-            throw ( (new Error(`Unknown extension ${extensionId.value}`)));
+            throw ( new Error(`Unknown extension ${extensionId.value}`));
         }
     }
     _onWillActivateExtension(extensionId, runningLocation) {
@@ -954,7 +985,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     }
     _onDidActivateExtension(extensionId, codeLoadingTime, activateCallTime, activateResolvedTime, activationReason) {
         const extensionStatus = this._getOrCreateExtensionStatus(extensionId);
-        extensionStatus.setActivationTimes(( (new ActivationTimes(codeLoadingTime, activateCallTime, activateResolvedTime, activationReason))));
+        extensionStatus.setActivationTimes(( new ActivationTimes(codeLoadingTime, activateCallTime, activateResolvedTime, activationReason)));
         this._onDidChangeExtensionsStatus.fire([extensionId]);
     }
     _onDidActivateExtensionError(extensionId, error) {
@@ -969,25 +1000,25 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         this._onDidChangeExtensionsStatus.fire([extensionId]);
     }
 };
-AbstractExtensionService = AbstractExtensionService_1 = ( (__decorate([
-    ( (__param(3, IInstantiationService))),
-    ( (__param(4, INotificationService))),
-    ( (__param(5, IWorkbenchEnvironmentService))),
-    ( (__param(6, ITelemetryService))),
-    ( (__param(7, IWorkbenchExtensionEnablementService))),
-    ( (__param(8, IFileService))),
-    ( (__param(9, IProductService))),
-    ( (__param(10, IWorkbenchExtensionManagementService))),
-    ( (__param(11, IWorkspaceContextService))),
-    ( (__param(12, IConfigurationService))),
-    ( (__param(13, IExtensionManifestPropertiesService))),
-    ( (__param(14, ILogService))),
-    ( (__param(15, IRemoteAgentService))),
-    ( (__param(16, IRemoteExtensionsScannerService))),
-    ( (__param(17, ILifecycleService))),
-    ( (__param(18, IRemoteAuthorityResolverService))),
-    ( (__param(19, IDialogService)))
-], AbstractExtensionService)));
+AbstractExtensionService = AbstractExtensionService_1 = ( __decorate([
+    ( __param(4, IInstantiationService)),
+    ( __param(5, INotificationService)),
+    ( __param(6, IWorkbenchEnvironmentService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IWorkbenchExtensionEnablementService)),
+    ( __param(9, IFileService)),
+    ( __param(10, IProductService)),
+    ( __param(11, IWorkbenchExtensionManagementService)),
+    ( __param(12, IWorkspaceContextService)),
+    ( __param(13, IConfigurationService)),
+    ( __param(14, IExtensionManifestPropertiesService)),
+    ( __param(15, ILogService)),
+    ( __param(16, IRemoteAgentService)),
+    ( __param(17, IRemoteExtensionsScannerService)),
+    ( __param(18, ILifecycleService)),
+    ( __param(19, IRemoteAuthorityResolverService)),
+    ( __param(20, IDialogService))
+], AbstractExtensionService));
 class ExtensionHostCollection extends Disposable {
     constructor() {
         super(...arguments);
@@ -1003,7 +1034,7 @@ class ExtensionHostCollection extends Disposable {
         super.dispose();
     }
     add(extensionHostManager, disposableStore) {
-        this._extensionHostManagers.push(( (new ExtensionHostManagerData(extensionHostManager, disposableStore))));
+        this._extensionHostManagers.push(( new ExtensionHostManagerData(extensionHostManager, disposableStore)));
     }
     async stopAllInReverse() {
         for (let i = this._extensionHostManagers.length - 1; i >= 0; i--) {
@@ -1038,17 +1069,13 @@ class ExtensionHostCollection extends Disposable {
         }
     }
     map(callback) {
-        return (
-             (this._extensionHostManagers.map(el => callback(el.extensionHost)))
-        );
+        return ( this._extensionHostManagers.map(el => callback(el.extensionHost)));
     }
     every(callback) {
         return this._extensionHostManagers.every(el => callback(el.extensionHost));
     }
     filter(callback) {
-        return (
-             (this._extensionHostManagers.filter(el => callback(el.extensionHost)).map(el => el.extensionHost))
-        );
+        return ( this._extensionHostManagers.filter(el => callback(el.extensionHost)).map(el => el.extensionHost));
     }
 }
 class ExtensionHostManagerData {
@@ -1061,12 +1088,19 @@ class ExtensionHostManagerData {
         this.extensionHost.dispose();
     }
 }
-class ResolvedExtensions {
-    constructor(local, remote, hasLocalProcess, allowRemoteExtensionsInLocalWebWorker) {
-        this.local = local;
-        this.remote = remote;
-        this.hasLocalProcess = hasLocalProcess;
-        this.allowRemoteExtensionsInLocalWebWorker = allowRemoteExtensionsInLocalWebWorker;
+class ResolverExtensions {
+    constructor(extensions) {
+        this.extensions = extensions;
+    }
+}
+class LocalExtensions {
+    constructor(extensions) {
+        this.extensions = extensions;
+    }
+}
+class RemoteExtensions {
+    constructor(extensions) {
+        this.extensions = extensions;
     }
 }
 class DeltaExtensionsQueueItem {
@@ -1075,6 +1109,9 @@ class DeltaExtensionsQueueItem {
         this.toRemove = toRemove;
     }
 }
+function isResolverExtension(extension) {
+    return !!extension.activationEvents?.some(activationEvent => activationEvent.startsWith('onResolveRemoteAuthority:'));
+}
 function checkEnabledAndProposedAPI(logService, extensionEnablementService, extensionsProposedApi, extensions, ignoreWorkspaceTrust) {
     extensionsProposedApi.updateEnabledApiProposals(extensions);
     return filterEnabledExtensions(logService, extensionEnablementService, extensions, ignoreWorkspaceTrust);
@@ -1185,7 +1222,7 @@ class ActivationFeatureMarkdowneRenderer extends Disposable {
     }
     render(manifest) {
         const activationEvents = manifest.activationEvents || [];
-        const data = ( (new MarkdownString()));
+        const data = ( new MarkdownString());
         if (activationEvents.length) {
             for (const activationEvent of activationEvents) {
                 data.appendMarkdown(`- \`${activationEvent}\`\n`);
@@ -1197,13 +1234,13 @@ class ActivationFeatureMarkdowneRenderer extends Disposable {
         };
     }
 }
-( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
+( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: 'activationEvents',
-    label: ( localize(1318, "Activation Events")),
+    label: ( localize(11484, "Activation Events")),
     access: {
         canToggle: false
     },
-    renderer: ( (new SyncDescriptor(ActivationFeatureMarkdowneRenderer))),
+    renderer: ( new SyncDescriptor(ActivationFeatureMarkdowneRenderer)),
 });
 
-export { AbstractExtensionService, DeltaExtensionsQueueItem, ExtensionHostCrashTracker, ExtensionStatus, ImplicitActivationAwareReader, ResolvedExtensions, checkEnabledAndProposedAPI, filterEnabledExtensions };
+export { AbstractExtensionService, DeltaExtensionsQueueItem, ExtensionHostCrashTracker, ExtensionStatus, ImplicitActivationAwareReader, LocalExtensions, RemoteExtensions, ResolverExtensions, checkEnabledAndProposedAPI, filterEnabledExtensions, isResolverExtension };