@codingame/monaco-vscode-extensions-service-override 4.5.0 → 4.5.2

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

@@ -46,6 +46,7 @@ import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/
 import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 
 var AbstractExtensionService_1;
+const _moduleId = "vs/workbench/services/extensions/common/abstractExtensionService";
 const hasOwnProperty = Object.hasOwnProperty;
 const NO_OP_VOID_PROMISE = Promise.resolve(undefined);
 let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtensionService extends Disposable {
@@ -71,24 +72,24 @@ 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 = [];
@@ -98,14 +99,14 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 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 = [];
@@ -118,16 +119,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 => {
@@ -135,7 +136,7 @@ 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) => {
@@ -147,9 +148,9 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             }
             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) => {
@@ -157,7 +158,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.onDidShutdown(() => {
@@ -199,7 +200,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++) {
@@ -233,32 +234,32 @@ 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,
                 message: ( localizeWithPath(
-                    'vs/workbench/services/extensions/common/abstractExtensionService',
-                    'looping',
+                    _moduleId,
+                    0,
                     "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)));
+        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) {
@@ -266,11 +267,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, []);
@@ -278,9 +279,9 @@ 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;
             }
@@ -309,7 +310,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;
@@ -329,16 +330,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))
@@ -347,9 +348,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() {
@@ -363,7 +364,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             for (const extHostManager of this._extensionHostManagers) {
                 if (extHostManager.startup !== 1 ) {
                     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))));
                 }
             }
         }
@@ -395,10 +396,10 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._notificationService.notify({
                 severity: Severity$1.Error,
                 message: ( localizeWithPath(
-                    'vs/workbench/services/extensions/common/abstractExtensionService',
-                    'looping',
+                    _moduleId,
+                    0,
                     "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(', ')
                 ))
             });
         }
@@ -411,10 +412,10 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         const extensionHostManager = this.findTestExtensionHost(this._environmentService.extensionTestsLocationURI);
         if (!extensionHostManager) {
             const msg = ( localizeWithPath(
-                'vs/workbench/services/extensions/common/abstractExtensionService',
-                'extensionTestError',
+                _moduleId,
+                1,
                 "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);
@@ -446,10 +447,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) {
@@ -460,7 +461,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;
@@ -515,12 +516,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') {
@@ -536,14 +537,18 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                 bestErrorResult = result;
             }
         }
-        throw new RemoteAuthorityResolverError(bestErrorResult.error.message, bestErrorResult.error.code, bestErrorResult.error.detail);
+        throw ( (new RemoteAuthorityResolverError(
+            bestErrorResult.error.message,
+            bestErrorResult.error.code,
+            bestErrorResult.error.detail
+        )));
     }
     stopExtensionHosts(reason) {
         return this._doStopExtensionHostsWithVeto(reason);
     }
     _doStopExtensionHosts() {
         const previouslyActivatedExtensionIds = [];
-        for (const extensionStatus of ( this._extensionStatus.values())) {
+        for (const extensionStatus of ( (this._extensionStatus.values()))) {
             if (extensionStatus.activationStarted) {
                 previouslyActivatedExtensionIds.push(extensionStatus.id);
             }
@@ -552,7 +557,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             this._extensionHostManagers[i].dispose();
         }
         this._extensionHostManagers = [];
-        for (const extensionStatus of ( this._extensionStatus.values())) {
+        for (const extensionStatus of ( (this._extensionStatus.values()))) {
             extensionStatus.clearRuntimeStatus();
         }
         if (previouslyActivatedExtensionIds.length > 0) {
@@ -561,7 +566,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     }
     async _doStopExtensionHostsWithVeto(reason) {
         const vetos = [];
-        const vetoReasons = ( new Set());
+        const vetoReasons = ( (new Set()));
         this._onWillStop.fire({
             reason,
             veto(value, reason) {
@@ -577,13 +582,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                             vetoReasons.add(reason);
                         }
                     }).catch(error => {
-                        vetoReasons.add(( localizeWithPath(
-                            'vs/workbench/services/extensions/common/abstractExtensionService',
-                            'extensionStopVetoError',
-                            "{0} (Error: {1})",
-                            reason,
-                            toErrorMessage(error)
-                        )));
+                        vetoReasons.add(( localizeWithPath(_moduleId, 2, "{0} (Error: {1})", reason, toErrorMessage(error))));
                     });
                 }
             }
@@ -595,21 +594,16 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         else {
             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(( localizeWithPath(
-                'vs/workbench/services/extensions/common/abstractExtensionService',
-                'extensionStopVetoMessage',
-                "The following operation was blocked: {0}",
-                reason
-            )), vetoReasonsArray.length === 1 ?
+            await this._dialogService.warn(( localizeWithPath(_moduleId, 3, "The following operation was blocked: {0}", reason)), vetoReasonsArray.length === 1 ?
                 ( localizeWithPath(
-                    'vs/workbench/services/extensions/common/abstractExtensionService',
-                    'extensionStopVetoDetailsOne',
+                    _moduleId,
+                    4,
                     "The reason for blocking the operation: {0}",
                     vetoReasonsArray[0]
                 )) :
                 ( localizeWithPath(
-                    'vs/workbench/services/extensions/common/abstractExtensionService',
-                    'extensionStopVetoDetailsMany',
+                    _moduleId,
+                    5,
                     "The reasons for blocking the operation:\n- {0}",
                     vetoReasonsArray.join('\n -')
                 )));
@@ -619,12 +613,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._getExtensionHostManagerByRunningLocation(location)) {
                 continue;
@@ -688,15 +682,17 @@ 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 {
@@ -709,25 +705,21 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             if (this._remoteCrashTracker.shouldAutomaticallyRestart()) {
                 this._logService.info(`Automatically restarting the remote extension host.`);
                 this._notificationService.status(( localizeWithPath(
-                    'vs/workbench/services/extensions/common/abstractExtensionService',
-                    'extensionService.autoRestart',
+                    _moduleId,
+                    6,
                     "The remote extension host terminated unexpectedly. Restarting..."
                 )), { hideAfter: 5000 });
-                this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
+                this._startExtensionHostsIfNecessary(false, Array.from(( (this._allRequestedActivateEvents.keys()))));
             }
             else {
                 this._notificationService.prompt(Severity$1.Error, ( localizeWithPath(
-                    'vs/workbench/services/extensions/common/abstractExtensionService',
-                    'extensionService.crash',
+                    _moduleId,
+                    7,
                     "Remote Extension host terminated unexpectedly 3 times within the last 5 minutes."
                 )), [{
-                        label: ( localizeWithPath(
-                            'vs/workbench/services/extensions/common/abstractExtensionService',
-                            'restart',
-                            "Restart Remote Extension Host"
-                        )),
+                        label: ( localizeWithPath(_moduleId, 8, "Restart Remote Extension Host")),
                         run: () => {
-                            this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
+                            this._startExtensionHostsIfNecessary(false, Array.from(( (this._allRequestedActivateEvents.keys()))));
                         }
                     }]);
             }
@@ -737,13 +729,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.`);
@@ -752,13 +744,13 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     async startExtensionHosts(updates) {
         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())));
+            this._startExtensionHostsIfNecessary(false, Array.from(( (this._allRequestedActivateEvents.keys()))));
             const localProcessExtensionHosts = this._getExtensionHostManagers(1 );
-            await Promise.all(( localProcessExtensionHosts.map(extHost => extHost.ready())));
+            await Promise.all(( (localProcessExtensionHosts.map(extHost => extHost.ready()))));
         }
         finally {
             lock.dispose();
@@ -781,9 +773,9 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         }
     }
     _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
@@ -822,7 +814,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;
@@ -847,12 +839,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(element => Boolean(element));
     }
     async setRemoteEnvironment(env) {
-        await ( this._extensionHostManagers
-            .map(manager => manager.setRemoteEnvironment(env)));
+        await ( (this._extensionHostManagers
+            .map(manager => manager.setRemoteEnvironment(env))));
     }
     _safeInvokeIsEnabled(extension) {
         try {
@@ -887,8 +879,8 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         mark('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);
     }
@@ -926,7 +918,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)))
                 });
             }
         }
@@ -952,10 +944,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) {
@@ -965,7 +957,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) {
@@ -980,25 +972,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(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)));
 class ResolvedExtensions {
     constructor(local, remote, hasLocalProcess, allowRemoteExtensionsInLocalWebWorker) {
         this.local = local;
@@ -1123,7 +1115,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`);
@@ -1135,17 +1127,13 @@ class ActivationFeatureMarkdowneRenderer extends Disposable {
         };
     }
 }
-( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'activationEvents',
-    label: ( localizeWithPath(
-        'vs/workbench/services/extensions/common/abstractExtensionService',
-        'activation',
-        "Activation Events"
-    )),
+    label: ( localizeWithPath(_moduleId, 9, "Activation Events")),
     access: {
         canToggle: false
     },
-    renderer: ( new SyncDescriptor(ActivationFeatureMarkdowneRenderer)),
+    renderer: ( (new SyncDescriptor(ActivationFeatureMarkdowneRenderer))),
 });
 
 export { AbstractExtensionService, DeltaExtensionsQueueItem, ExtensionHostCrashTracker, ExtensionStatus, ImplicitActivationAwareReader, ResolvedExtensions, checkEnabledAndProposedAPI, filterEnabledExtensions };