@codingame/monaco-vscode-api 1.83.0-next.0 → 1.83.2

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

@@ -64,24 +64,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 = [];
@@ -91,14 +91,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 = [];
@@ -111,16 +111,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.onDidInstallExtensions((result) => {
@@ -132,9 +132,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) => {
@@ -142,7 +142,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(() => {
@@ -184,7 +184,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++) {
@@ -218,30 +218,30 @@ 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.Error,
-                message: ( (nls.localize(
+                message: ( nls.localize(
                     'looping',
                     "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([].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) {
@@ -249,11 +249,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, []);
@@ -261,9 +261,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;
             }
@@ -295,7 +295,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             if (activationEvent === 'onUri') {
                 activationEvent = `onUri:${ExtensionIdentifier.toKey(extensionDescription.identifier)}`;
             }
-            if (( (this._allRequestedActivateEvents.has(activationEvent)))) {
+            if (( this._allRequestedActivateEvents.has(activationEvent))) {
                 shouldActivate = true;
                 shouldActivateReason = activationEvent;
                 break;
@@ -315,16 +315,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))
@@ -333,9 +333,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() {
@@ -349,7 +349,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)));
                 }
             }
         }
@@ -380,11 +380,11 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         if (result.removedDueToLooping.length > 0) {
             this._notificationService.notify({
                 severity: Severity.Error,
-                message: ( (nls.localize(
+                message: ( nls.localize(
                     'looping',
                     "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());
@@ -395,11 +395,11 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         }
         const extensionHostManager = this.findTestExtensionHost(this._environmentService.extensionTestsLocationURI);
         if (!extensionHostManager) {
-            const msg = ( (nls.localize(
+            const msg = ( nls.localize(
                 'extensionTestError',
                 "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);
             return;
@@ -430,10 +430,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) {
@@ -444,7 +444,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;
@@ -502,9 +502,9 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
             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') {
@@ -527,7 +527,7 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
     }
     _doStopExtensionHosts() {
         const previouslyActivatedExtensionIds = [];
-        for (const extensionStatus of ( (this._extensionStatus.values()))) {
+        for (const extensionStatus of ( this._extensionStatus.values())) {
             if (extensionStatus.activationStarted) {
                 previouslyActivatedExtensionIds.push(extensionStatus.id);
             }
@@ -536,7 +536,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) {
@@ -545,7 +545,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) {
@@ -561,12 +561,12 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
                             vetoReasons.add(reason);
                         }
                     }).catch(error => {
-                        vetoReasons.add(( (nls.localize(
+                        vetoReasons.add(( nls.localize(
                             'extensionStopVetoError',
                             "{0} (Error: {1})",
                             reason,
                             toErrorMessage(error)
-                        ))));
+                        )));
                     });
                 }
             }
@@ -578,33 +578,33 @@ 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(( (nls.localize(
+            await this._dialogService.warn(( nls.localize(
                 'extensionStopVetoMessage',
                 "The following operation was blocked: {0}",
                 reason
-            ))), vetoReasonsArray.length === 1 ?
-                ( (nls.localize(
-                'extensionStopVetoDetailsOne',
-                "The reason for blocking the operation: {0}",
-                vetoReasonsArray[0]
-            ))) :
-                ( (nls.localize(
-                'extensionStopVetoDetailsMany',
-                "The reasons for blocking the operation:\n- {0}",
-                vetoReasonsArray.join('\n -')
-            ))));
+            )), vetoReasonsArray.length === 1 ?
+                ( nls.localize(
+                    'extensionStopVetoDetailsOne',
+                    "The reason for blocking the operation: {0}",
+                    vetoReasonsArray[0]
+                )) :
+                ( nls.localize(
+                    'extensionStopVetoDetailsMany',
+                    "The reasons for blocking the operation:\n- {0}",
+                    vetoReasonsArray.join('\n -')
+                )));
         }
         return !veto;
     }
     _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;
@@ -663,17 +663,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 {
@@ -685,20 +683,20 @@ 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(( (nls.localize(
+                this._notificationService.status(( nls.localize(
                     'extensionService.autoRestart',
                     "The remote extension host terminated unexpectedly. Restarting..."
-                ))), { hideAfter: 5000 });
-                this._startExtensionHostsIfNecessary(false, Array.from(( (this._allRequestedActivateEvents.keys()))));
+                )), { hideAfter: 5000 });
+                this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
             }
             else {
-                this._notificationService.prompt(Severity.Error, ( (nls.localize(
+                this._notificationService.prompt(Severity.Error, ( nls.localize(
                     'extensionService.crash',
                     "Remote Extension host terminated unexpectedly 3 times within the last 5 minutes."
-                ))), [{
-                        label: ( (nls.localize('restart', "Restart Remote Extension Host"))),
+                )), [{
+                        label: ( nls.localize('restart', "Restart Remote Extension Host")),
                         run: () => {
-                            this._startExtensionHostsIfNecessary(false, Array.from(( (this._allRequestedActivateEvents.keys()))));
+                            this._startExtensionHostsIfNecessary(false, Array.from(( this._allRequestedActivateEvents.keys())));
                         }
                     }]);
             }
@@ -708,13 +706,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 (${extensionHostKindToString(extensionHost.kind)}) terminated unexpectedly. The following extensions were running: ${( ( activatedExtensions.map(id => id.value))).join(', ')}`);
+            this._logService.error(`Extension host (${extensionHostKindToString(extensionHost.kind)}) terminated unexpectedly. The following extensions were running: ${( activatedExtensions.map(id => id.value)).join(', ')}`);
         }
         else {
             this._logService.error(`Extension host (${extensionHostKindToString(extensionHost.kind)}) terminated unexpectedly. No extensions were activated.`);
@@ -724,9 +722,9 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         this._doStopExtensionHosts();
         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();
@@ -749,9 +747,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
@@ -787,7 +785,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;
@@ -812,12 +810,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 {
@@ -852,8 +850,8 @@ let AbstractExtensionService = AbstractExtensionService_1 = class AbstractExtens
         performance.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);
     }
@@ -891,7 +889,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))
                 });
             }
         }
@@ -917,8 +915,8 @@ 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}`);
         }
@@ -930,7 +928,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) {
@@ -945,25 +943,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;