@codingame/monaco-vscode-api 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/api/common/extHostExtensionService.js

@@ -41,9 +41,23 @@ import { isCI, isWebWorker, setTimeout0 } from '../../../base/common/platform.js
 import { IExtHostManagedSockets } from './extHostManagedSockets.js';
 
 var AbstractExtHostExtensionService_1;
-const IHostUtils = ( createDecorator('IHostUtils'));
+const IHostUtils = ( createDecorator("IHostUtils"));
 let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class AbstractExtHostExtensionService extends Disposable {
-    constructor(instaService, hostUtils, extHostContext, extHostWorkspace, extHostConfiguration, logService, initData, storagePath, extHostTunnelService, extHostTerminalService, extHostLocalizationService, _extHostManagedSockets, _extHostLanguageModels) {
+    constructor(
+        instaService,
+        hostUtils,
+        extHostContext,
+        extHostWorkspace,
+        extHostConfiguration,
+        logService,
+        initData,
+        storagePath,
+        extHostTunnelService,
+        extHostTerminalService,
+        extHostLocalizationService,
+        _extHostManagedSockets,
+        _extHostLanguageModels
+    ) {
         super();
         this._extHostManagedSockets = _extHostManagedSockets;
         this._extHostLanguageModels = _extHostLanguageModels;
@@ -75,8 +89,12 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             filterExtensions(this._globalRegistry, myExtensionsSet)
         ));
         if (isCI) {
-            this._logService.info(`Creating extension host with the following global extensions: ${printExtIds(this._globalRegistry)}`);
-            this._logService.info(`Creating extension host with the following local extensions: ${printExtIds(this._myRegistry)}`);
+            this._logService.info(
+                `Creating extension host with the following global extensions: ${printExtIds(this._globalRegistry)}`
+            );
+            this._logService.info(
+                `Creating extension host with the following local extensions: ${printExtIds(this._myRegistry)}`
+            );
         }
         this._storage = ( new ExtHostStorage(this._extHostContext, this._logService));
         this._secretState = ( new ExtHostSecretState(this._extHostContext));
@@ -84,7 +102,11 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         this._instaService = this._store.add(instaService.createChild(( new ServiceCollection([IExtHostStorage, this._storage], [IExtHostSecretState, this._secretState]))));
         this._activator = this._register(( new ExtensionsActivator(this._myRegistry, this._globalRegistry, {
             onExtensionActivationError: (extensionId, error, missingExtensionDependency) => {
-                this._mainThreadExtensionsProxy.$onExtensionActivationError(extensionId, transformErrorForSerialization(error), missingExtensionDependency);
+                this._mainThreadExtensionsProxy.$onExtensionActivationError(
+                    extensionId,
+                    transformErrorForSerialization(error),
+                    missingExtensionDependency
+                );
             },
             actualActivateExtension: async (extensionId, reason) => {
                 if (ExtensionDescriptionRegistry.isHostExtension(extensionId, this._myRegistry, this._globalRegistry)) {
@@ -108,13 +130,12 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             await this._beforeAlmostReadyToRunExtensions();
             this._almostReadyToRunExtensions.open();
             await this._extHostWorkspace.waitForInitializeCall();
-            mark('code/extHost/ready');
+            mark("code/extHost/ready");
             this._readyToStartExtensionHost.open();
             if (this._initData.autoStart) {
                 this._startExtensionHost();
             }
-        }
-        catch (err) {
+        } catch (err) {
             onUnexpectedError(err);
         }
     }
@@ -125,12 +146,10 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             const allExtensions = this._myRegistry.getAllExtensionDescriptions();
             const allExtensionsIds = ( allExtensions.map(ext => ext.identifier));
             const activatedExtensions = allExtensionsIds.filter(id => this.isActivated(id));
-            allPromises = ( activatedExtensions.map((extensionId) => {
+            allPromises = ( activatedExtensions.map(extensionId => {
                 return this._deactivate(extensionId);
             }));
-        }
-        catch (err) {
-        }
+        } catch (err) {}
         await Promise.all(allPromises);
     }
     terminate(reason, code = 0) {
@@ -143,7 +162,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         this._extHostTerminalService.dispose();
         this._activator.dispose();
         if (isWebWorker) {
-            setUnexpectedErrorHandler((err) => {
+            setUnexpectedErrorHandler(err => {
                 this._logService.error(err);
             });
         }
@@ -152,8 +171,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         Promise.race([timeout(5000), extensionsDeactivated]).finally(() => {
             if (this._hostUtils.pid) {
                 this._logService.info(`Extension host with pid ${this._hostUtils.pid} exiting with code ${code}`);
-            }
-            else {
+            } else {
                 this._logService.info(`Extension host exiting with code ${code}`);
             }
             this._logService.flush();
@@ -196,12 +214,10 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
     getExtensionExports(extensionId) {
         if (this._readyToRunExtensions.isOpen()) {
             return this._activator.getActivatedExtension(extensionId).exports;
-        }
-        else {
+        } else {
             try {
                 return this._activator.getActivatedExtension(extensionId).exports;
-            }
-            catch (err) {
+            } catch (err) {
                 return null;
             }
         }
@@ -219,7 +235,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
     }
     async getExtensionPathIndex() {
         if (!this._extensionPathIndex) {
-            this._extensionPathIndex = this._createExtensionPathIndex(this._myRegistry.getAllExtensionDescriptions()).then((searchTree) => {
+            this._extensionPathIndex = this._createExtensionPathIndex(this._myRegistry.getAllExtensionDescriptions()).then(searchTree => {
                 return ( new ExtensionPaths(searchTree));
             });
         }
@@ -229,7 +245,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         const tst = TernarySearchTree.forUris(key => {
             return extUriBiasedIgnorePathCase.ignorePathCasing(key);
         });
-        await Promise.all(( extensions.map(async (ext) => {
+        await Promise.all(( extensions.map(async ext => {
             if (this._getEntryPoint(ext)) {
                 const uri = await this._realPathExtensionUri(ext.extensionLocation);
                 tst.set(uri, ext);
@@ -250,22 +266,24 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             return result;
         }
         try {
-            if (typeof extension.module.deactivate === 'function') {
-                result = Promise.resolve(extension.module.deactivate()).then(undefined, (err) => {
+            if (typeof extension.module.deactivate === "function") {
+                result = Promise.resolve(extension.module.deactivate()).then(undefined, err => {
                     this._logService.error(err);
                     return Promise.resolve(undefined);
                 });
             }
-        }
-        catch (err) {
-            this._logService.error(`An error occurred when deactivating the extension '${extensionId.value}':`);
+        } catch (err) {
+            this._logService.error(
+                `An error occurred when deactivating the extension '${extensionId.value}':`
+            );
             this._logService.error(err);
         }
         try {
             extension.disposable.dispose();
-        }
-        catch (err) {
-            this._logService.error(`An error occurred when disposing the subscriptions for extension '${extensionId.value}':`);
+        } catch (err) {
+            this._logService.error(
+                `An error occurred when disposing the subscriptions for extension '${extensionId.value}':`
+            );
             this._logService.error(err);
         }
         return result;
@@ -273,23 +291,28 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
     async _activateExtension(extensionDescription, reason) {
         if (!this._initData.remote.isRemote) {
             await this._mainThreadExtensionsProxy.$onWillActivateExtension(extensionDescription.identifier);
-        }
-        else {
+        } else {
             this._mainThreadExtensionsProxy.$onWillActivateExtension(extensionDescription.identifier);
         }
-        return this._doActivateExtension(extensionDescription, reason).then((activatedExtension) => {
+        return this._doActivateExtension(extensionDescription, reason).then(activatedExtension => {
             const activationTimes = activatedExtension.activationTimes;
-            this._mainThreadExtensionsProxy.$onDidActivateExtension(extensionDescription.identifier, activationTimes.codeLoadingTime, activationTimes.activateCallTime, activationTimes.activateResolvedTime, reason);
-            this._logExtensionActivationTimes(extensionDescription, reason, 'success', activationTimes);
+            this._mainThreadExtensionsProxy.$onDidActivateExtension(
+                extensionDescription.identifier,
+                activationTimes.codeLoadingTime,
+                activationTimes.activateCallTime,
+                activationTimes.activateResolvedTime,
+                reason
+            );
+            this._logExtensionActivationTimes(extensionDescription, reason, "success", activationTimes);
             return activatedExtension;
-        }, (err) => {
-            this._logExtensionActivationTimes(extensionDescription, reason, 'failure');
+        }, err => {
+            this._logExtensionActivationTimes(extensionDescription, reason, "failure");
             throw err;
         });
     }
     _logExtensionActivationTimes(extensionDescription, reason, outcome, activationTimes) {
         const event = getTelemetryActivationEvent(extensionDescription, reason);
-        this._mainThreadTelemetryProxy.$publicLog2('extensionActivationTimes', {
+        this._mainThreadTelemetryProxy.$publicLog2("extensionActivationTimes", {
             ...event,
             ...(activationTimes || {}),
             outcome
@@ -297,26 +320,42 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
     }
     _doActivateExtension(extensionDescription, reason) {
         const event = getTelemetryActivationEvent(extensionDescription, reason);
-        this._mainThreadTelemetryProxy.$publicLog2('activatePlugin', event);
+        this._mainThreadTelemetryProxy.$publicLog2("activatePlugin", event);
         const entryPoint = this._getEntryPoint(extensionDescription);
         if (!entryPoint) {
             return Promise.resolve(( new EmptyExtension(ExtensionActivationTimes.NONE)));
         }
-        this._logService.info(`ExtensionService#_doActivateExtension ${extensionDescription.identifier.value}, startup: ${reason.startup}, activationEvent: '${reason.activationEvent}'${extensionDescription.identifier.value !== reason.extensionId.value ? `, root cause: ${reason.extensionId.value}` : ``}`);
+        this._logService.info(
+            `ExtensionService#_doActivateExtension ${extensionDescription.identifier.value}, startup: ${reason.startup}, activationEvent: '${reason.activationEvent}'${extensionDescription.identifier.value !== reason.extensionId.value ? `, root cause: ${reason.extensionId.value}` : ``}`
+        );
         this._logService.flush();
         const isESM = this._isESM(extensionDescription);
         const extensionInternalStore = ( new DisposableStore());
         const activationTimesBuilder = ( new ExtensionActivationTimesBuilder(reason.startup));
-        return Promise.all([
-            isESM
-                ? this._loadESMModule(extensionDescription, joinPath(extensionDescription.extensionLocation, entryPoint), activationTimesBuilder)
-                : this._loadCommonJSModule(extensionDescription, joinPath(extensionDescription.extensionLocation, entryPoint), activationTimesBuilder),
-            this._loadExtensionContext(extensionDescription, extensionInternalStore)
-        ]).then(values => {
-            mark(`code/extHost/willActivateExtension/${extensionDescription.identifier.value}`);
-            return AbstractExtHostExtensionService_1._callActivate(this._logService, extensionDescription.identifier, values[0], values[1], extensionInternalStore, activationTimesBuilder);
-        }).then((activatedExtension) => {
-            mark(`code/extHost/didActivateExtension/${extensionDescription.identifier.value}`);
+        return Promise.all([isESM ? this._loadESMModule(
+            extensionDescription,
+            joinPath(extensionDescription.extensionLocation, entryPoint),
+            activationTimesBuilder
+        ) : this._loadCommonJSModule(
+            extensionDescription,
+            joinPath(extensionDescription.extensionLocation, entryPoint),
+            activationTimesBuilder
+        ), this._loadExtensionContext(extensionDescription, extensionInternalStore)]).then(values => {
+            mark(
+                `code/extHost/willActivateExtension/${extensionDescription.identifier.value}`
+            );
+            return AbstractExtHostExtensionService_1._callActivate(
+                this._logService,
+                extensionDescription.identifier,
+                values[0],
+                values[1],
+                extensionInternalStore,
+                activationTimesBuilder
+            );
+        }).then(activatedExtension => {
+            mark(
+                `code/extHost/didActivateExtension/${extensionDescription.identifier.value}`
+            );
             return activatedExtension;
         });
     }
@@ -325,11 +364,11 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         const globalState = extensionInternalStore.add(( new ExtensionGlobalMemento(extensionDescription, this._storage)));
         const workspaceState = extensionInternalStore.add(( new ExtensionMemento(extensionDescription.identifier.value, false, this._storage)));
         const secrets = extensionInternalStore.add(( new ExtensionSecrets(extensionDescription, this._secretState)));
-        const extensionMode = extensionDescription.isUnderDevelopment
-            ? (this._initData.environment.extensionTestsLocationURI ? ExtensionMode.Test : ExtensionMode.Development)
-            : ExtensionMode.Production;
+        const extensionMode = extensionDescription.isUnderDevelopment ? (this._initData.environment.extensionTestsLocationURI ? ExtensionMode.Test : ExtensionMode.Development) : ExtensionMode.Production;
         const extensionKind = this._initData.remote.isRemote ? ExtensionKind.Workspace : ExtensionKind.UI;
-        this._logService.trace(`ExtensionService#loadExtensionContext ${extensionDescription.identifier.value}`);
+        this._logService.trace(
+            `ExtensionService#loadExtensionContext ${extensionDescription.identifier.value}`
+        );
         return Promise.all([
             globalState.whenReady,
             workspaceState.whenReady,
@@ -338,25 +377,45 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             const that = this;
             let extension;
             let messagePassingProtocol;
-            const messagePort = isProposedApiEnabled(extensionDescription, 'ipc')
-                ? this._initData.messagePorts?.get(ExtensionIdentifier.toKey(extensionDescription.identifier))
-                : undefined;
+            const messagePort = isProposedApiEnabled(extensionDescription, "ipc") ? this._initData.messagePorts?.get(ExtensionIdentifier.toKey(extensionDescription.identifier)) : undefined;
             return ( Object.freeze({
                 globalState,
                 workspaceState,
                 secrets,
                 subscriptions: [],
-                get languageModelAccessInformation() { return languageModelAccessInformation; },
-                get extensionUri() { return extensionDescription.extensionLocation; },
-                get extensionPath() { return extensionDescription.extensionLocation.fsPath; },
-                asAbsolutePath(relativePath) { return join(extensionDescription.extensionLocation.fsPath, relativePath); },
-                get storagePath() { return that._storagePath.workspaceValue(extensionDescription)?.fsPath; },
-                get globalStoragePath() { return that._storagePath.globalValue(extensionDescription).fsPath; },
-                get logPath() { return join(that._initData.logsLocation.fsPath, extensionDescription.identifier.value); },
-                get logUri() { return URI.joinPath(that._initData.logsLocation, extensionDescription.identifier.value); },
-                get storageUri() { return that._storagePath.workspaceValue(extensionDescription); },
-                get globalStorageUri() { return that._storagePath.globalValue(extensionDescription); },
-                get extensionMode() { return extensionMode; },
+                get languageModelAccessInformation() {
+                    return languageModelAccessInformation;
+                },
+                get extensionUri() {
+                    return extensionDescription.extensionLocation;
+                },
+                get extensionPath() {
+                    return extensionDescription.extensionLocation.fsPath;
+                },
+                asAbsolutePath(relativePath) {
+                    return join(extensionDescription.extensionLocation.fsPath, relativePath);
+                },
+                get storagePath() {
+                    return that._storagePath.workspaceValue(extensionDescription)?.fsPath;
+                },
+                get globalStoragePath() {
+                    return that._storagePath.globalValue(extensionDescription).fsPath;
+                },
+                get logPath() {
+                    return join(that._initData.logsLocation.fsPath, extensionDescription.identifier.value);
+                },
+                get logUri() {
+                    return URI.joinPath(that._initData.logsLocation, extensionDescription.identifier.value);
+                },
+                get storageUri() {
+                    return that._storagePath.workspaceValue(extensionDescription);
+                },
+                get globalStorageUri() {
+                    return that._storagePath.globalValue(extensionDescription);
+                },
+                get extensionMode() {
+                    return extensionMode;
+                },
                 get extension() {
                     if (extension === undefined) {
                         extension = ( new Extension(
@@ -370,16 +429,18 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
                     return extension;
                 },
                 get extensionRuntime() {
-                    checkProposedApiEnabled(extensionDescription, 'extensionRuntime');
+                    checkProposedApiEnabled(extensionDescription, "extensionRuntime");
                     return that.extensionRuntime;
                 },
-                get environmentVariableCollection() { return that._extHostTerminalService.getEnvironmentVariableCollection(extensionDescription); },
+                get environmentVariableCollection() {
+                    return that._extHostTerminalService.getEnvironmentVariableCollection(extensionDescription);
+                },
                 get messagePassingProtocol() {
                     if (!messagePassingProtocol) {
                         if (!messagePort) {
                             return undefined;
                         }
-                        const onDidReceiveMessage = Event.buffer(Event.fromDOMEventEmitter(messagePort, 'message', e => e.data));
+                        const onDidReceiveMessage = Event.buffer(Event.fromDOMEventEmitter(messagePort, "message", e => e.data));
                         messagePort.start();
                         messagePassingProtocol = {
                             onDidReceiveMessage,
@@ -391,12 +452,19 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             }));
         });
     }
-    static _callActivate(logService, extensionId, extensionModule, context, extensionInternalStore, activationTimesBuilder) {
+    static _callActivate(
+        logService,
+        extensionId,
+        extensionModule,
+        context,
+        extensionInternalStore,
+        activationTimesBuilder
+    ) {
         extensionModule = extensionModule || {
             activate: undefined,
             deactivate: undefined
         };
-        return this._callActivateOptional(logService, extensionId, extensionModule, context, activationTimesBuilder).then((extensionExports) => {
+        return this._callActivateOptional(logService, extensionId, extensionModule, context, activationTimesBuilder).then(extensionExports => {
             return ( new ActivatedExtension(
                 false,
                 null,
@@ -411,23 +479,21 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         });
     }
     static _callActivateOptional(logService, extensionId, extensionModule, context, activationTimesBuilder) {
-        if (typeof extensionModule.activate === 'function') {
+        if (typeof extensionModule.activate === "function") {
             try {
                 activationTimesBuilder.activateCallStart();
                 logService.trace(`ExtensionService#_callActivateOptional ${extensionId.value}`);
                 const activateResult = extensionModule.activate.apply(globalThis, [context]);
                 activationTimesBuilder.activateCallStop();
                 activationTimesBuilder.activateResolveStart();
-                return Promise.resolve(activateResult).then((value) => {
+                return Promise.resolve(activateResult).then(value => {
                     activationTimesBuilder.activateResolveStop();
                     return value;
                 });
-            }
-            catch (err) {
+            } catch (err) {
                 return Promise.reject(err);
             }
-        }
-        else {
+        } else {
             return Promise.resolve(extensionModule);
         }
     }
@@ -436,7 +502,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             startup: false,
             extensionId: desc.identifier,
             activationEvent: activationEvent
-        }).then(undefined, (err) => {
+        }).then(undefined, err => {
             this._logService.error(err);
         });
     }
@@ -447,12 +513,11 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             for (let i = start; i < extensions.length; i += 1) {
                 const desc = extensions[i];
                 for (const activationEvent of (desc.activationEvents ?? [])) {
-                    if (activationEvent === 'onStartupFinished') {
+                    if (activationEvent === "onStartupFinished") {
                         if (Date.now() - startTime > timeBudget) {
                             this._activateAllStartupFinishedDeferred(extensions, i);
                             break;
-                        }
-                        else {
+                        } else {
                             this._activateOneStartupFinished(desc, activationEvent);
                         }
                     }
@@ -462,17 +527,16 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
     }
     _activateAllStartupFinished() {
         this._mainThreadExtensionsProxy.$setPerformanceMarks(getMarks());
-        this._extHostConfiguration.getConfigProvider().then((configProvider) => {
-            const shouldDeferActivation = configProvider.getConfiguration('extensions.experimental').get('deferredStartupFinishedActivation');
+        this._extHostConfiguration.getConfigProvider().then(configProvider => {
+            const shouldDeferActivation = configProvider.getConfiguration("extensions.experimental").get("deferredStartupFinishedActivation");
             const allExtensionDescriptions = this._myRegistry.getAllExtensionDescriptions();
             if (shouldDeferActivation) {
                 this._activateAllStartupFinishedDeferred(allExtensionDescriptions);
-            }
-            else {
+            } else {
                 for (const desc of allExtensionDescriptions) {
                     if (desc.activationEvents) {
                         for (const activationEvent of desc.activationEvents) {
-                            if (activationEvent === 'onStartupFinished') {
+                            if (activationEvent === "onStartupFinished") {
                                 this._activateOneStartupFinished(desc, activationEvent);
                             }
                         }
@@ -482,14 +546,16 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         });
     }
     _handleEagerExtensions() {
-        const starActivation = this._activateByEvent('*', true).then(undefined, (err) => {
+        const starActivation = this._activateByEvent("*", true).then(undefined, err => {
             this._logService.error(err);
         });
-        this._register(this._extHostWorkspace.onDidChangeWorkspace((e) => this._handleWorkspaceContainsEagerExtensions(e.added)));
+        this._register(
+            this._extHostWorkspace.onDidChangeWorkspace(e => this._handleWorkspaceContainsEagerExtensions(e.added))
+        );
         const folders = this._extHostWorkspace.workspace ? this._extHostWorkspace.workspace.folders : [];
         const workspaceContainsActivation = this._handleWorkspaceContainsEagerExtensions(folders);
         const remoteResolverActivation = this._handleRemoteResolverEagerExtensions();
-        const eagerExtensionsActivation = Promise.all([remoteResolverActivation, starActivation, workspaceContainsActivation]).then(() => { });
+        const eagerExtensionsActivation = Promise.all([remoteResolverActivation, starActivation, workspaceContainsActivation]).then(() => {});
         Promise.race([eagerExtensionsActivation, timeout(10000)]).then(() => {
             this._activateAllStartupFinished();
         });
@@ -499,9 +565,9 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         if (folders.length === 0) {
             return Promise.resolve(undefined);
         }
-        return Promise.all(( this._myRegistry.getAllExtensionDescriptions().map((desc) => {
+        return Promise.all(( this._myRegistry.getAllExtensionDescriptions().map(desc => {
             return this._handleWorkspaceContainsEagerExtension(folders, desc);
-        }))).then(() => { });
+        }))).then(() => {});
     }
     async _handleWorkspaceContainsEagerExtension(folders, desc) {
         if (this.isActivated(desc.identifier)) {
@@ -512,15 +578,18 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             logService: this._logService,
             folders: ( folders.map(folder => folder.uri)),
             forceUsingSearch: localWithRemote || !this._hostUtils.fsExists,
-            exists: (uri) => this._hostUtils.fsExists(uri.fsPath),
+            exists: uri => this._hostUtils.fsExists(uri.fsPath),
             checkExists: (folders, includes, token) => this._mainThreadWorkspaceProxy.$checkExists(folders, includes, token)
         };
         const result = await checkActivateWorkspaceContainsExtension(host, desc);
         if (!result) {
             return;
         }
-        return (this._activateById(desc.identifier, { startup: true, extensionId: desc.identifier, activationEvent: result.activationEvent })
-            .then(undefined, err => this._logService.error(err)));
+        return (this._activateById(desc.identifier, {
+            startup: true,
+            extensionId: desc.identifier,
+            activationEvent: result.activationEvent
+        }).then(undefined, err => this._logService.error(err)));
     }
     async _handleRemoteResolverEagerExtensions() {
         if (this._initData.remote.authority) {
@@ -531,25 +600,25 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         await this._eagerExtensionsActivated.wait();
         try {
             return await this._doHandleExtensionTests();
-        }
-        catch (error) {
+        } catch (error) {
             console.error(error);
             throw error;
         }
     }
     async _doHandleExtensionTests() {
-        const { extensionDevelopmentLocationURI, extensionTestsLocationURI } = this._initData.environment;
+        const {
+            extensionDevelopmentLocationURI,
+            extensionTestsLocationURI
+        } = this._initData.environment;
         if (!extensionDevelopmentLocationURI || !extensionTestsLocationURI) {
-            throw ( new Error(( localize(2690, "Cannot load test runner."))));
+            throw ( new Error(( localize(2693, "Cannot load test runner."))));
         }
         const extensionDescription = (await this.getExtensionPathIndex()).findSubstr(extensionTestsLocationURI);
         const isESM = this._isESM(extensionDescription, extensionTestsLocationURI.path);
-        const testRunner = await (isESM
-            ? this._loadESMModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false)))
-            : this._loadCommonJSModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))));
-        if (!testRunner || typeof testRunner.run !== 'function') {
+        const testRunner = await (isESM ? this._loadESMModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))) : this._loadCommonJSModule(null, extensionTestsLocationURI, ( new ExtensionActivationTimesBuilder(false))));
+        if (!testRunner || typeof testRunner.run !== "function") {
             throw ( new Error(( localize(
-                2691,
+                2694,
                 "Path {0} does not point to a valid extension test runner.",
                 (extensionTestsLocationURI.toString())
             ))));
@@ -561,30 +630,28 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
                         this._logService.error(`Test runner called back with error`, error);
                     }
                     reject(error);
-                }
-                else {
+                } else {
                     if (isCI) {
                         if (failures) {
                             this._logService.info(`Test runner called back with ${failures} failures.`);
-                        }
-                        else {
+                        } else {
                             this._logService.info(`Test runner called back with successful outcome.`);
                         }
                     }
-                    resolve((typeof failures === 'number' && failures > 0) ? 1  : 0 );
+                    resolve(
+                        (typeof failures === "number" && failures > 0) ? 1  : 0
+                    );
                 }
             };
             const extensionTestsPath = originalFSPath(extensionTestsLocationURI);
             const runResult = testRunner.run(extensionTestsPath, oldTestRunnerCallback);
             if (runResult && runResult.then) {
-                runResult
-                    .then(() => {
+                runResult.then(() => {
                     if (isCI) {
                         this._logService.info(`Test runner finished successfully.`);
                     }
                     resolve(0);
-                })
-                    .catch((err) => {
+                }).catch(err => {
                     if (isCI) {
                         this._logService.error(`Test runner finished with error`, err);
                     }
@@ -598,13 +665,9 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             throw ( new Error(`Extension host is already started!`));
         }
         this._started = true;
-        return this._readyToStartExtensionHost.wait()
-            .then(() => this._readyToRunExtensions.open())
-            .then(() => {
+        return this._readyToStartExtensionHost.wait().then(() => this._readyToRunExtensions.open()).then(() => {
             return Promise.race([this._activator.waitForActivatingExtensions(), timeout(1000)]);
-        })
-            .then(() => this._handleEagerExtensions())
-            .then(() => {
+        }).then(() => this._handleEagerExtensions()).then(() => {
             this._eagerExtensionsActivated.open();
             this._logService.info(`Eager extensions activated`);
         });
@@ -616,11 +679,15 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         });
     }
     async getRemoteExecServer(remoteAuthority) {
-        const { resolver } = await this._activateAndGetResolver(remoteAuthority);
-        return resolver?.resolveExecServer?.(remoteAuthority, { resolveAttempt: 0 });
+        const {
+            resolver
+        } = await this._activateAndGetResolver(remoteAuthority);
+        return resolver?.resolveExecServer?.(remoteAuthority, {
+            resolveAttempt: 0
+        });
     }
     async _activateAndGetResolver(remoteAuthority) {
-        const authorityPlusIndex = remoteAuthority.indexOf('+');
+        const authorityPlusIndex = remoteAuthority.indexOf("+");
         if (authorityPlusIndex === -1) {
             throw ( new RemoteAuthorityResolverError(
                 `Not an authority that can be resolved!`,
@@ -630,18 +697,21 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         const authorityPrefix = remoteAuthority.substr(0, authorityPlusIndex);
         await this._almostReadyToRunExtensions.wait();
         await this._activateByEvent(`onResolveRemoteAuthority:${authorityPrefix}`, false);
-        return { authorityPrefix, resolver: this._resolvers[authorityPrefix] };
+        return {
+            authorityPrefix,
+            resolver: this._resolvers[authorityPrefix]
+        };
     }
     async $resolveAuthority(remoteAuthorityChain, resolveAttempt) {
         const sw = StopWatch.create(false);
         const prefix = () => `[resolveAuthority(${getRemoteAuthorityPrefix(remoteAuthorityChain)},${resolveAttempt})][${sw.elapsed()}ms] `;
-        const logInfo = (msg) => this._logService.info(`${prefix()}${msg}`);
-        const logWarning = (msg) => this._logService.warn(`${prefix()}${msg}`);
+        const logInfo = msg => this._logService.info(`${prefix()}${msg}`);
+        const logWarning = msg => this._logService.warn(`${prefix()}${msg}`);
         const logError = (msg, err = undefined) => this._logService.error(`${prefix()}${msg}`, err);
-        const normalizeError = (err) => {
+        const normalizeError = err => {
             if (err instanceof RemoteAuthorityResolverError) {
                 return {
-                    type: 'error',
+                    type: "error",
                     error: {
                         code: err._code,
                         message: err._message,
@@ -651,9 +721,12 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             }
             throw err;
         };
-        const getResolver = async (remoteAuthority) => {
+        const getResolver = async remoteAuthority => {
             logInfo(`activating resolver for ${remoteAuthority}...`);
-            const { resolver, authorityPrefix } = await this._activateAndGetResolver(remoteAuthority);
+            const {
+                resolver,
+                authorityPrefix
+            } = await this._activateAndGetResolver(remoteAuthority);
             if (!resolver) {
                 logError(`no resolver for ${authorityPrefix}`);
                 throw ( new RemoteAuthorityResolverError(
@@ -661,41 +734,56 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
                     RemoteAuthorityResolverErrorCode.NoResolverFound
                 ));
             }
-            return { resolver, authorityPrefix, remoteAuthority };
+            return {
+                resolver,
+                authorityPrefix,
+                remoteAuthority
+            };
         };
         const chain = remoteAuthorityChain.split(/@|%40/g).reverse();
-        logInfo(`activating remote resolvers ${chain.join(' -> ')}`);
+        logInfo(`activating remote resolvers ${chain.join(" -> ")}`);
         let resolvers;
         try {
-            resolvers = await Promise.all(( chain.map(getResolver))).catch(async (e) => {
+            resolvers = await Promise.all(( chain.map(getResolver))).catch(async e => {
                 if (!(e instanceof RemoteAuthorityResolverError) || e._code !== RemoteAuthorityResolverErrorCode.InvalidAuthority) {
                     throw e;
                 }
                 logWarning(`resolving nested authorities failed: ${e.message}`);
                 return [await getResolver(remoteAuthorityChain)];
             });
-        }
-        catch (e) {
+        } catch (e) {
             return normalizeError(e);
         }
         const intervalLogger = ( new IntervalTimer());
-        intervalLogger.cancelAndSet(() => logInfo('waiting...'), 1000);
+        intervalLogger.cancelAndSet(() => logInfo("waiting..."), 1000);
         let result;
         let execServer;
-        for (const [i, { authorityPrefix, resolver, remoteAuthority }] of resolvers.entries()) {
+        for (const [i, {
+            authorityPrefix,
+            resolver,
+            remoteAuthority
+        }] of resolvers.entries()) {
             try {
                 if (i === resolvers.length - 1) {
                     logInfo(`invoking final resolve()...`);
                     mark(`code/extHost/willResolveAuthority/${authorityPrefix}`);
-                    result = await resolver.resolve(remoteAuthority, { resolveAttempt, execServer });
+                    result = await resolver.resolve(remoteAuthority, {
+                        resolveAttempt,
+                        execServer
+                    });
                     mark(`code/extHost/didResolveAuthorityOK/${authorityPrefix}`);
                     logInfo(`setting tunnel factory...`);
-                    this._register(await this._extHostTunnelService.setTunnelFactory(resolver, ManagedResolvedAuthority.isManagedResolvedAuthority(result) ? result : undefined));
-                }
-                else {
+                    this._register(await this._extHostTunnelService.setTunnelFactory(
+                        resolver,
+                        ManagedResolvedAuthority.isManagedResolvedAuthority(result) ? result : undefined
+                    ));
+                } else {
                     logInfo(`invoking resolveExecServer() for ${remoteAuthority}`);
                     mark(`code/extHost/willResolveExecServer/${authorityPrefix}`);
-                    execServer = await resolver.resolveExecServer?.(remoteAuthority, { resolveAttempt, execServer });
+                    execServer = await resolver.resolveExecServer?.(remoteAuthority, {
+                        resolveAttempt,
+                        execServer
+                    });
                     if (!execServer) {
                         throw ( new RemoteAuthorityResolverError(
                             `Exec server was not available for ${remoteAuthority}`,
@@ -704,8 +792,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
                     }
                     mark(`code/extHost/didResolveExecServerOK/${authorityPrefix}`);
                 }
-            }
-            catch (e) {
+            } catch (e) {
                 mark(`code/extHost/didResolveAuthorityError/${authorityPrefix}`);
                 logError(`returned an error`, e);
                 intervalLogger.dispose();
@@ -718,15 +805,20 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             features: result.tunnelFeatures ? {
                 elevation: result.tunnelFeatures.elevation,
                 privacyOptions: result.tunnelFeatures.privacyOptions,
-                protocol: result.tunnelFeatures.protocol === undefined ? true : result.tunnelFeatures.protocol,
+                protocol: result.tunnelFeatures.protocol === undefined ? true : result.tunnelFeatures.protocol
             } : undefined
         };
         const options = {
             extensionHostEnv: result.extensionHostEnv,
             isTrusted: result.isTrusted,
-            authenticationSession: result.authenticationSessionForInitializingExtensions ? { id: result.authenticationSessionForInitializingExtensions.id, providerId: result.authenticationSessionForInitializingExtensions.providerId } : undefined
+            authenticationSession: result.authenticationSessionForInitializingExtensions ? {
+                id: result.authenticationSessionForInitializingExtensions.id,
+                providerId: result.authenticationSessionForInitializingExtensions.providerId
+            } : undefined
         };
-        logInfo(`returned ${ManagedResolvedAuthority.isManagedResolvedAuthority(result) ? 'managed authority' : `${result.host}:${result.port}`}`);
+        logInfo(
+            `returned ${ManagedResolvedAuthority.isManagedResolvedAuthority(result) ? "managed authority" : `${result.host}:${result.port}`}`
+        );
         let authority;
         if (ManagedResolvedAuthority.isManagedResolvedAuthority(result)) {
             const socketFactoryId = resolveAttempt;
@@ -736,8 +828,7 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
                 connectTo: ( new ManagedRemoteConnection(socketFactoryId)),
                 connectionToken: result.connectionToken
             };
-        }
-        else {
+        } else {
             authority = {
                 authority: remoteAuthorityChain,
                 connectTo: ( new WebSocketRemoteConnection(result.host, result.port)),
@@ -745,22 +836,26 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
             };
         }
         return {
-            type: 'ok',
+            type: "ok",
             value: {
                 authority: authority,
                 options,
-                tunnelInformation,
+                tunnelInformation
             }
         };
     }
     async $getCanonicalURI(remoteAuthority, uriComponents) {
-        this._logService.info(`$getCanonicalURI invoked for authority (${getRemoteAuthorityPrefix(remoteAuthority)})`);
-        const { resolver } = await this._activateAndGetResolver(remoteAuthority);
+        this._logService.info(
+            `$getCanonicalURI invoked for authority (${getRemoteAuthorityPrefix(remoteAuthority)})`
+        );
+        const {
+            resolver
+        } = await this._activateAndGetResolver(remoteAuthority);
         if (!resolver) {
             return null;
         }
         const uri = URI.revive(uriComponents);
-        if (typeof resolver.getCanonicalURI === 'undefined') {
+        if (typeof resolver.getCanonicalURI === "undefined") {
             return uri;
         }
         const result = await asPromise(() => resolver.getCanonicalURI(uri));
@@ -770,26 +865,36 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         return result;
     }
     async $startExtensionHost(extensionsDelta) {
-        extensionsDelta.toAdd.forEach((extension) => extension.extensionLocation = URI.revive(extension.extensionLocation));
-        const { globalRegistry, myExtensions } = applyExtensionsDelta(this._activationEventsReader, this._globalRegistry, this._myRegistry, extensionsDelta);
+        extensionsDelta.toAdd.forEach(
+            extension => extension.extensionLocation = URI.revive(extension.extensionLocation)
+        );
+        const {
+            globalRegistry,
+            myExtensions
+        } = applyExtensionsDelta(
+            this._activationEventsReader,
+            this._globalRegistry,
+            this._myRegistry,
+            extensionsDelta
+        );
         const newSearchTree = await this._createExtensionPathIndex(myExtensions);
         const extensionsPaths = await this.getExtensionPathIndex();
         extensionsPaths.setSearchTree(newSearchTree);
         this._globalRegistry.set(globalRegistry.getAllExtensionDescriptions());
         this._myRegistry.set(myExtensions);
         if (isCI) {
-            this._logService.info(`$startExtensionHost: global extensions: ${printExtIds(this._globalRegistry)}`);
+            this._logService.info(
+                `$startExtensionHost: global extensions: ${printExtIds(this._globalRegistry)}`
+            );
             this._logService.info(`$startExtensionHost: local extensions: ${printExtIds(this._myRegistry)}`);
         }
         return this._startExtensionHost();
     }
     $activateByEvent(activationEvent, activationKind) {
         if (activationKind === ActivationKind.Immediate) {
-            return this._almostReadyToRunExtensions.wait()
-                .then(_ => this._activateByEvent(activationEvent, false));
+            return this._almostReadyToRunExtensions.wait().then(_ => this._activateByEvent(activationEvent, false));
         }
-        return (this._readyToRunExtensions.wait()
-            .then(_ => this._activateByEvent(activationEvent, false)));
+        return (this._readyToRunExtensions.wait().then(_ => this._activateByEvent(activationEvent, false)));
     }
     async $activate(extensionId, reason) {
         await this._readyToRunExtensions.wait();
@@ -800,15 +905,27 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
         return true;
     }
     async $deltaExtensions(extensionsDelta) {
-        extensionsDelta.toAdd.forEach((extension) => extension.extensionLocation = URI.revive(extension.extensionLocation));
-        const { globalRegistry, myExtensions } = applyExtensionsDelta(this._activationEventsReader, this._globalRegistry, this._myRegistry, extensionsDelta);
+        extensionsDelta.toAdd.forEach(
+            extension => extension.extensionLocation = URI.revive(extension.extensionLocation)
+        );
+        const {
+            globalRegistry,
+            myExtensions
+        } = applyExtensionsDelta(
+            this._activationEventsReader,
+            this._globalRegistry,
+            this._myRegistry,
+            extensionsDelta
+        );
         const newSearchTree = await this._createExtensionPathIndex(myExtensions);
         const extensionsPaths = await this.getExtensionPathIndex();
         extensionsPaths.setSearchTree(newSearchTree);
         this._globalRegistry.set(globalRegistry.getAllExtensionDescriptions());
         this._myRegistry.set(myExtensions);
         if (isCI) {
-            this._logService.info(`$deltaExtensions: global extensions: ${printExtIds(this._globalRegistry)}`);
+            this._logService.info(
+                `$deltaExtensions: global extensions: ${printExtIds(this._globalRegistry)}`
+            );
             this._logService.info(`$deltaExtensions: local extensions: ${printExtIds(this._myRegistry)}`);
         }
         return Promise.resolve(undefined);
@@ -833,24 +950,10 @@ let AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = class
     }
     _isESM(extensionDescription, modulePath) {
         modulePath ??= extensionDescription ? this._getEntryPoint(extensionDescription) : modulePath;
-        return modulePath?.endsWith('.mjs') || (extensionDescription?.type === 'module' && !modulePath?.endsWith('.cjs'));
+        return modulePath?.endsWith(".mjs") || (extensionDescription?.type === "module" && !modulePath?.endsWith(".cjs"));
     }
 };
-AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IHostUtils)),
-    ( __param(2, IExtHostRpcService)),
-    ( __param(3, IExtHostWorkspace)),
-    ( __param(4, IExtHostConfiguration)),
-    ( __param(5, ILogService)),
-    ( __param(6, IExtHostInitDataService)),
-    ( __param(7, IExtensionStoragePaths)),
-    ( __param(8, IExtHostTunnelService)),
-    ( __param(9, IExtHostTerminalService)),
-    ( __param(10, IExtHostLocalizationService)),
-    ( __param(11, IExtHostManagedSockets)),
-    ( __param(12, IExtHostLanguageModels))
-], AbstractExtHostExtensionService));
+AbstractExtHostExtensionService = AbstractExtHostExtensionService_1 = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IHostUtils)), ( __param(2, IExtHostRpcService)), ( __param(3, IExtHostWorkspace)), ( __param(4, IExtHostConfiguration)), ( __param(5, ILogService)), ( __param(6, IExtHostInitDataService)), ( __param(7, IExtensionStoragePaths)), ( __param(8, IExtHostTunnelService)), ( __param(9, IExtHostTerminalService)), ( __param(10, IExtHostLocalizationService)), ( __param(11, IExtHostManagedSockets)), ( __param(12, IExtHostLanguageModels))], AbstractExtHostExtensionService));
 function applyExtensionsDelta(activationEventsReader, oldGlobalRegistry, oldMyRegistry, extensionsDelta) {
     activationEventsReader.addActivationEvents(extensionsDelta.addActivationEvents);
     const globalRegistry = ( new ExtensionDescriptionRegistry(activationEventsReader, oldGlobalRegistry.getAllExtensionDescriptions()));
@@ -863,7 +966,10 @@ function applyExtensionsDelta(activationEventsReader, oldGlobalRegistry, oldMyRe
         myExtensionsSet.add(extensionId);
     }
     const myExtensions = filterExtensions(globalRegistry, myExtensionsSet);
-    return { globalRegistry, myExtensions };
+    return {
+        globalRegistry,
+        myExtensions
+    };
 }
 function getTelemetryActivationEvent(extensionDescription, reason) {
     const event = {
@@ -871,22 +977,28 @@ function getTelemetryActivationEvent(extensionDescription, reason) {
         name: extensionDescription.name,
         extensionVersion: extensionDescription.version,
         publisherDisplayName: extensionDescription.publisher,
-        activationEvents: extensionDescription.activationEvents ? extensionDescription.activationEvents.join(',') : null,
+        activationEvents: extensionDescription.activationEvents ? extensionDescription.activationEvents.join(",") : null,
         isBuiltin: extensionDescription.isBuiltin,
         reason: reason.activationEvent,
-        reasonId: reason.extensionId.value,
+        reasonId: reason.extensionId.value
     };
     return event;
 }
 function printExtIds(registry) {
-    return ( registry.getAllExtensionDescriptions().map(ext => ext.identifier.value)).join(',');
+    return ( registry.getAllExtensionDescriptions().map(ext => ext.identifier.value)).join(",");
 }
-const IExtHostExtensionService = ( createDecorator('IExtHostExtensionService'));
+const IExtHostExtensionService = ( createDecorator("IExtHostExtensionService"));
 class Extension {
     #extensionService;
     #originExtensionId;
     #identifier;
-    constructor(extensionService, originExtensionId, description, kind, isFromDifferentExtensionHost) {
+    constructor(
+        extensionService,
+        originExtensionId,
+        description,
+        kind,
+        isFromDifferentExtensionHost
+    ) {
         this.#extensionService = extensionService;
         this.#originExtensionId = originExtensionId;
         this.#identifier = description.identifier;
@@ -902,16 +1014,20 @@ class Extension {
         return this.#extensionService.isActivated(this.#identifier);
     }
     get exports() {
-        if (this.packageJSON.api === 'none' || this.isFromDifferentExtensionHost) {
+        if (this.packageJSON.api === "none" || this.isFromDifferentExtensionHost) {
             return undefined;
         }
         return this.#extensionService.getExtensionExports(this.#identifier);
     }
     async activate() {
         if (this.isFromDifferentExtensionHost) {
-            throw ( new Error('Cannot activate foreign extension'));
+            throw ( new Error("Cannot activate foreign extension"));
         }
-        await this.#extensionService.activateByIdWithErrors(this.#identifier, { startup: false, extensionId: this.#originExtensionId, activationEvent: 'api' });
+        await this.#extensionService.activateByIdWithErrors(this.#identifier, {
+            startup: false,
+            extensionId: this.#originExtensionId,
+            activationEvent: "api"
+        });
         return this.exports;
     }
 }