@codingame/monaco-vscode-extensions-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/api/browser/mainThreadTelemetry.js

@@ -12,9 +12,19 @@ import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode
 
 var MainThreadTelemetry_1;
 let MainThreadTelemetry = class MainThreadTelemetry extends Disposable {
-    static { MainThreadTelemetry_1 = this; }
-    static { this._name = 'pluginHostTelemetry'; }
-    constructor(extHostContext, _telemetryService, _configurationService, _environmentService, _productService) {
+    static {
+        MainThreadTelemetry_1 = this;
+    }
+    static {
+        this._name = "pluginHostTelemetry";
+    }
+    constructor(
+        extHostContext,
+        _telemetryService,
+        _configurationService,
+        _environmentService,
+        _productService
+    ) {
         super();
         this._telemetryService = _telemetryService;
         this._configurationService = _configurationService;
@@ -28,7 +38,11 @@ let MainThreadTelemetry = class MainThreadTelemetry extends Disposable {
                 }
             }));
         }
-        this._proxy.$initializeTelemetryLevel(this.telemetryLevel, supportsTelemetry(this._productService, this._environmentService), this._productService.enabledTelemetryLevels);
+        this._proxy.$initializeTelemetryLevel(
+            this.telemetryLevel,
+            supportsTelemetry(this._productService, this._environmentService),
+            this._productService.enabledTelemetryLevels
+        );
     }
     get telemetryLevel() {
         if (!supportsTelemetry(this._productService, this._environmentService)) {
@@ -44,12 +58,6 @@ let MainThreadTelemetry = class MainThreadTelemetry extends Disposable {
         this.$publicLog(eventName, data);
     }
 };
-MainThreadTelemetry = MainThreadTelemetry_1 = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadTelemetry),
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IEnvironmentService)),
-    ( __param(4, IProductService))
-], MainThreadTelemetry);
+MainThreadTelemetry = MainThreadTelemetry_1 = __decorate([extHostNamedCustomer(MainContext.MainThreadTelemetry), ( __param(1, ITelemetryService)), ( __param(2, IConfigurationService)), ( __param(3, IEnvironmentService)), ( __param(4, IProductService))], MainThreadTelemetry);
 
 export { MainThreadTelemetry };

package/vscode/src/vs/workbench/api/browser/mainThreadTerminalService.js

@@ -25,7 +25,22 @@ import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscod
 import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 
 let MainThreadTerminalService = class MainThreadTerminalService extends Disposable {
-    constructor(_extHostContext, _terminalService, _terminalLinkProviderService, _terminalQuickFixService, _instantiationService, _environmentVariableService, _logService, _terminalProfileResolverService, remoteAgentService, _terminalGroupService, _terminalEditorService, _terminalProfileService, _terminalCompletionService, _environmentService) {
+    constructor(
+        _extHostContext,
+        _terminalService,
+        _terminalLinkProviderService,
+        _terminalQuickFixService,
+        _instantiationService,
+        _environmentVariableService,
+        _logService,
+        _terminalProfileResolverService,
+        remoteAgentService,
+        _terminalGroupService,
+        _terminalEditorService,
+        _terminalProfileService,
+        _terminalCompletionService,
+        _environmentService
+    ) {
         super();
         this._terminalService = _terminalService;
         this._terminalLinkProviderService = _terminalLinkProviderService;
@@ -49,20 +64,40 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
         this._linkProvider = this._register(( new MutableDisposable()));
         this._os = OS;
         this._proxy = ( _extHostContext.getProxy(ExtHostContext.ExtHostTerminalService));
-        this._register(_terminalService.onDidCreateInstance((instance) => {
+        this._register(_terminalService.onDidCreateInstance(instance => {
             this._onTerminalOpened(instance);
             this._onInstanceDimensionsChanged(instance);
         }));
-        this._register(_terminalService.onDidDisposeInstance(instance => this._onTerminalDisposed(instance)));
-        this._register(_terminalService.onAnyInstanceProcessIdReady(instance => this._onTerminalProcessIdReady(instance)));
-        this._register(_terminalService.onDidChangeInstanceDimensions(instance => this._onInstanceDimensionsChanged(instance)));
-        this._register(_terminalService.onAnyInstanceMaximumDimensionsChange(instance => this._onInstanceMaximumDimensionsChanged(instance)));
-        this._register(_terminalService.onDidRequestStartExtensionTerminal(e => this._onRequestStartExtensionTerminal(e)));
-        this._register(_terminalService.onDidChangeActiveInstance(instance => this._onActiveTerminalChanged(instance ? instance.instanceId : null)));
-        this._register(_terminalService.onAnyInstanceTitleChange(instance => instance && this._onTitleChanged(instance.instanceId, instance.title)));
-        this._register(_terminalService.onAnyInstanceDataInput(instance => this._proxy.$acceptTerminalInteraction(instance.instanceId)));
-        this._register(_terminalService.onAnyInstanceSelectionChange(instance => this._proxy.$acceptTerminalSelection(instance.instanceId, instance.selection)));
-        this._register(_terminalService.onAnyInstanceShellTypeChanged(instance => this._onShellTypeChanged(instance.instanceId)));
+        this._register(
+            _terminalService.onDidDisposeInstance(instance => this._onTerminalDisposed(instance))
+        );
+        this._register(
+            _terminalService.onAnyInstanceProcessIdReady(instance => this._onTerminalProcessIdReady(instance))
+        );
+        this._register(
+            _terminalService.onDidChangeInstanceDimensions(instance => this._onInstanceDimensionsChanged(instance))
+        );
+        this._register(
+            _terminalService.onAnyInstanceMaximumDimensionsChange(instance => this._onInstanceMaximumDimensionsChanged(instance))
+        );
+        this._register(
+            _terminalService.onDidRequestStartExtensionTerminal(e => this._onRequestStartExtensionTerminal(e))
+        );
+        this._register(_terminalService.onDidChangeActiveInstance(
+            instance => this._onActiveTerminalChanged(instance ? instance.instanceId : null)
+        ));
+        this._register(_terminalService.onAnyInstanceTitleChange(
+            instance => instance && this._onTitleChanged(instance.instanceId, instance.title)
+        ));
+        this._register(
+            _terminalService.onAnyInstanceDataInput(instance => this._proxy.$acceptTerminalInteraction(instance.instanceId))
+        );
+        this._register(_terminalService.onAnyInstanceSelectionChange(
+            instance => this._proxy.$acceptTerminalSelection(instance.instanceId, instance.selection)
+        ));
+        this._register(
+            _terminalService.onAnyInstanceShellTypeChanged(instance => this._onShellTypeChanged(instance.instanceId))
+        );
         for (const instance of this._terminalService.instances) {
             this._onTerminalOpened(instance);
             instance.processReady.then(() => this._onTerminalProcessIdReady(instance));
@@ -88,11 +123,13 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
             }
             this._terminalProcessProxies.clear();
         }));
-        remoteAgentService.getEnvironment().then(async (env) => {
+        remoteAgentService.getEnvironment().then(async env => {
             this._os = env?.os || OS;
             this._updateDefaultProfile();
         });
-        this._register(this._terminalProfileService.onDidChangeAvailableProfiles(() => this._updateDefaultProfile()));
+        this._register(
+            this._terminalProfileService.onDidChangeAvailableProfiles(() => this._updateDefaultProfile())
+        );
         this._register(toDisposable(() => {
             for (const provider of ( this._profileProviders.values())) {
                 provider.dispose();
@@ -104,12 +141,19 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
     }
     async _updateDefaultProfile() {
         const remoteAuthority = this._environmentService.remoteAuthority;
-        const defaultProfile = this._terminalProfileResolverService.getDefaultProfile({ remoteAuthority, os: this._os });
-        const defaultAutomationProfile = this._terminalProfileResolverService.getDefaultProfile({ remoteAuthority, os: this._os, allowAutomationShell: true });
+        const defaultProfile = this._terminalProfileResolverService.getDefaultProfile({
+            remoteAuthority,
+            os: this._os
+        });
+        const defaultAutomationProfile = this._terminalProfileResolverService.getDefaultProfile({
+            remoteAuthority,
+            os: this._os,
+            allowAutomationShell: true
+        });
         this._proxy.$acceptDefaultProfile(...(await Promise.all([defaultProfile, defaultAutomationProfile])));
     }
     async _getTerminalInstance(id) {
-        if (typeof id === 'string') {
+        if (typeof id === "string") {
             return this._extHostTerminals.get(id);
         }
         return this._terminalService.getInstanceFromId(id);
@@ -119,7 +163,7 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
             name: launchConfig.name,
             executable: launchConfig.shellPath,
             args: launchConfig.shellArgs,
-            cwd: typeof launchConfig.cwd === 'string' ? launchConfig.cwd : URI.revive(launchConfig.cwd),
+            cwd: typeof launchConfig.cwd === "string" ? launchConfig.cwd : URI.revive(launchConfig.cwd),
             icon: launchConfig.icon,
             color: launchConfig.color,
             initialText: launchConfig.initialText,
@@ -128,9 +172,7 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
             env: launchConfig.env,
             strictEnv: launchConfig.strictEnv,
             hideFromUser: launchConfig.hideFromUser,
-            customPtyImplementation: launchConfig.isExtensionCustomPtyTerminal
-                ? (id, cols, rows) => ( new TerminalProcessExtHostProxy(id, cols, rows, this._terminalService))
-                : undefined,
+            customPtyImplementation: launchConfig.isExtensionCustomPtyTerminal ? (id, cols, rows) => ( new TerminalProcessExtHostProxy(id, cols, rows, this._terminalService)) : undefined,
             extHostTerminalId,
             forceShellIntegration: launchConfig.forceShellIntegration,
             isFeatureTerminal: launchConfig.isFeatureTerminal,
@@ -139,7 +181,7 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
             isTransient: launchConfig.isTransient,
             shellIntegrationNonce: launchConfig.shellIntegrationNonce
         };
-        const terminal = Promises.withAsyncBody(async (r) => {
+        const terminal = Promises.withAsyncBody(async r => {
             const terminal = await this._terminalService.createTerminal({
                 config: shellLaunchConfig,
                 location: await this._deserializeParentTerminal(launchConfig.location)
@@ -153,9 +195,13 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
         }));
     }
     async _deserializeParentTerminal(location) {
-        if (typeof location === 'object' && hasKey(location, { parentTerminal: true })) {
+        if (typeof location === "object" && hasKey(location, {
+            parentTerminal: true
+        })) {
             const parentTerminal = await this._extHostTerminals.get(( location.parentTerminal.toString()));
-            return parentTerminal ? { parentTerminal } : undefined;
+            return parentTerminal ? {
+                parentTerminal
+            } : undefined;
         }
         return location;
     }
@@ -165,8 +211,7 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
             this._terminalService.setActiveInstance(terminalInstance);
             if (terminalInstance.target === TerminalLocation.Editor) {
                 await this._terminalEditorService.revealActiveEditor(preserveFocus);
-            }
-            else {
+            } else {
                 await this._terminalGroupService.showPanel(!preserveFocus);
             }
         }
@@ -207,7 +252,10 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
         if (this._sendCommandEventListener.value) {
             return;
         }
-        const multiplexer = this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CommandDetection, capability => capability.onCommandFinished);
+        const multiplexer = this._terminalService.createOnInstanceCapabilityEvent(
+            TerminalCapability.CommandDetection,
+            capability => capability.onCommandFinished
+        );
         const sub = multiplexer.event(e => {
             this._onDidExecuteCommand(e.instance.instanceId, {
                 commandLine: e.data.command,
@@ -231,44 +279,57 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
         this._terminalService.registerProcessSupport(isSupported);
     }
     $registerCompletionProvider(id, extensionIdentifier, ...triggerCharacters) {
-        this._completionProviders.set(id, this._terminalCompletionService.registerTerminalCompletionProvider(extensionIdentifier, id, {
+        this._completionProviders.set(
             id,
-            provideCompletions: async (commandLine, cursorIndex, token) => {
-                const completions = await this._proxy.$provideTerminalCompletions(id, { commandLine, cursorIndex }, token);
-                if (!completions) {
-                    return undefined;
-                }
-                if (completions.resourceOptions) {
-                    const { cwd, globPattern, ...rest } = completions.resourceOptions;
-                    return {
-                        items: completions.items?.map(c => ({
-                            provider: `ext:${id}`,
-                            ...c,
-                        })),
-                        resourceOptions: {
-                            ...rest,
+            this._terminalCompletionService.registerTerminalCompletionProvider(extensionIdentifier, id, {
+                id,
+                provideCompletions: async (commandLine, cursorIndex, token) => {
+                    const completions = await this._proxy.$provideTerminalCompletions(id, {
+                        commandLine,
+                        cursorIndex
+                    }, token);
+                    if (!completions) {
+                        return undefined;
+                    }
+                    if (completions.resourceOptions) {
+                        const {
                             cwd,
-                            globPattern
-                        }
-                    };
+                            globPattern,
+                            ...rest
+                        } = completions.resourceOptions;
+                        return {
+                            items: completions.items?.map(c => ({
+                                provider: `ext:${id}`,
+                                ...c
+                            })),
+                            resourceOptions: {
+                                ...rest,
+                                cwd,
+                                globPattern
+                            }
+                        };
+                    }
+                    return completions.items?.map(c => ({
+                        provider: `ext:${id}`,
+                        ...c
+                    }));
                 }
-                return completions.items?.map(c => ({
-                    provider: `ext:${id}`,
-                    ...c,
-                }));
-            }
-        }, ...triggerCharacters));
+            }, ...triggerCharacters)
+        );
     }
     $unregisterCompletionProvider(id) {
         this._completionProviders.get(id)?.dispose();
         this._completionProviders.delete(id);
     }
     $registerProfileProvider(id, extensionIdentifier) {
-        this._profileProviders.set(id, this._terminalProfileService.registerTerminalProfileProvider(extensionIdentifier, id, {
-            createContributedTerminalProfile: async (options) => {
-                return this._proxy.$createContributedProfileTerminal(id, options);
-            }
-        }));
+        this._profileProviders.set(
+            id,
+            this._terminalProfileService.registerTerminalProfileProvider(extensionIdentifier, id, {
+                createContributedTerminalProfile: async options => {
+                    return this._proxy.$createContributedProfileTerminal(id, options);
+                }
+            })
+        );
     }
     $unregisterProfileProvider(id) {
         this._profileProviders.get(id)?.dispose();
@@ -282,7 +343,7 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
                 }
                 if (options.outputMatcher?.length && options.outputMatcher.length > 40) {
                     options.outputMatcher.length = 40;
-                    this._logService.warn('Cannot exceed output matcher length of 40');
+                    this._logService.warn("Cannot exceed output matcher length of 40");
                 }
                 const commandLineMatch = terminalCommand.command.match(options.commandLineMatcher);
                 if (!commandLineMatch || !lines) {
@@ -296,13 +357,16 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
                 if (!outputMatch) {
                     return;
                 }
-                const matchResult = { commandLineMatch, outputMatch, commandLine: terminalCommand.command };
+                const matchResult = {
+                    commandLineMatch,
+                    outputMatch,
+                    commandLine: terminalCommand.command
+                };
                 if (matchResult) {
                     const result = await this._proxy.$provideTerminalQuickFixes(id, matchResult, token);
                     if (result && Array.isArray(result)) {
                         return ( result.map(r => parseQuickFix(id, extensionId, r)));
-                    }
-                    else if (result) {
+                    } else if (result) {
                         return parseQuickFix(id, extensionId, result);
                     }
                 }
@@ -333,7 +397,11 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
         }
     }
     _onTerminalDisposed(terminalInstance) {
-        this._proxy.$acceptTerminalClosed(terminalInstance.instanceId, terminalInstance.exitCode, terminalInstance.exitReason ?? TerminalExitReason.Unknown);
+        this._proxy.$acceptTerminalClosed(
+            terminalInstance.instanceId,
+            terminalInstance.exitCode,
+            terminalInstance.exitReason ?? TerminalExitReason.Unknown
+        );
         const proxy = this._terminalProcessProxies.get(terminalInstance.instanceId);
         if (proxy) {
             proxy.proxy.dispose();
@@ -352,7 +420,12 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
             hideFromUser: terminalInstance.shellLaunchConfig.hideFromUser,
             tabActions: terminalInstance.shellLaunchConfig.tabActions
         };
-        this._proxy.$acceptTerminalOpened(terminalInstance.instanceId, extHostTerminalId, terminalInstance.title, shellLaunchConfigDto);
+        this._proxy.$acceptTerminalOpened(
+            terminalInstance.instanceId,
+            extHostTerminalId,
+            terminalInstance.title,
+            shellLaunchConfigDto
+        );
     }
     _onTerminalProcessIdReady(terminalInstance) {
         if (terminalInstance.processId === undefined) {
@@ -369,16 +442,27 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
     _onRequestStartExtensionTerminal(request) {
         const proxy = request.proxy;
         const store = ( new DisposableStore());
-        this._terminalProcessProxies.set(proxy.instanceId, { proxy, store });
+        this._terminalProcessProxies.set(proxy.instanceId, {
+            proxy,
+            store
+        });
         const initialDimensions = request.cols && request.rows ? {
             columns: request.cols,
             rows: request.rows
         } : undefined;
         this._proxy.$startExtensionTerminal(proxy.instanceId, initialDimensions).then(request.callback);
-        store.add(proxy.onInput(data => this._proxy.$acceptProcessInput(proxy.instanceId, data)));
-        store.add(proxy.onShutdown(immediate => this._proxy.$acceptProcessShutdown(proxy.instanceId, immediate)));
-        store.add(proxy.onRequestCwd(() => this._proxy.$acceptProcessRequestCwd(proxy.instanceId)));
-        store.add(proxy.onRequestInitialCwd(() => this._proxy.$acceptProcessRequestInitialCwd(proxy.instanceId)));
+        store.add(
+            proxy.onInput(data => this._proxy.$acceptProcessInput(proxy.instanceId, data))
+        );
+        store.add(proxy.onShutdown(
+            immediate => this._proxy.$acceptProcessShutdown(proxy.instanceId, immediate)
+        ));
+        store.add(
+            proxy.onRequestCwd(() => this._proxy.$acceptProcessRequestCwd(proxy.instanceId))
+        );
+        store.add(
+            proxy.onRequestInitialCwd(() => this._proxy.$acceptProcessRequestInitialCwd(proxy.instanceId))
+        );
     }
     $sendProcessData(terminalId, data) {
         this._terminalProcessProxies.get(terminalId)?.proxy.emitData(data);
@@ -401,8 +485,7 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
                 descriptionMap: deserializeEnvironmentDescriptionMap(descriptionMap)
             };
             this._environmentVariableService.set(extensionIdentifier, translatedCollection);
-        }
-        else {
+        } else {
             this._environmentVariableService.delete(extensionIdentifier);
         }
     }
@@ -432,16 +515,18 @@ let TerminalDataEventTracker = class TerminalDataEventTracker extends Disposable
         for (const instance of this._terminalService.instances) {
             this._registerInstance(instance);
         }
-        this._register(this._terminalService.onDidCreateInstance(instance => this._registerInstance(instance)));
-        this._register(this._terminalService.onDidDisposeInstance(instance => this._bufferer.stopBuffering(instance.instanceId)));
+        this._register(
+            this._terminalService.onDidCreateInstance(instance => this._registerInstance(instance))
+        );
+        this._register(
+            this._terminalService.onDidDisposeInstance(instance => this._bufferer.stopBuffering(instance.instanceId))
+        );
     }
     _registerInstance(instance) {
         this._register(this._bufferer.startBuffering(instance.instanceId, instance.onData));
     }
 };
-TerminalDataEventTracker = ( __decorate([
-    ( __param(1, ITerminalService))
-], TerminalDataEventTracker));
+TerminalDataEventTracker = ( __decorate([( __param(1, ITerminalService))], TerminalDataEventTracker));
 class ExtensionTerminalLinkProvider {
     constructor(_proxy) {
         this._proxy = _proxy;
@@ -459,19 +544,30 @@ class ExtensionTerminalLinkProvider {
     }
 }
 function getOutputMatchForLines(lines, outputMatcher) {
-    const match = lines.join('\n').match(outputMatcher.lineMatcher);
-    return match ? { regexMatch: match, outputLines: lines } : undefined;
+    const match = lines.join("\n").match(outputMatcher.lineMatcher);
+    return match ? {
+        regexMatch: match,
+        outputLines: lines
+    } : undefined;
 }
 function parseQuickFix(id, source, fix) {
     let type = TerminalQuickFixType.TerminalCommand;
-    if (hasKey(fix, { uri: true })) {
+    if (hasKey(fix, {
+        uri: true
+    })) {
         fix.uri = URI.revive(fix.uri);
         type = TerminalQuickFixType.Opener;
-    }
-    else if (hasKey(fix, { id: true })) {
+    } else if (hasKey(fix, {
+        id: true
+    })) {
         type = TerminalQuickFixType.VscodeCommand;
     }
-    return { id, type, source, ...fix };
+    return {
+        id,
+        type,
+        source,
+        ...fix
+    };
 }
 
 export { MainThreadTerminalService, getOutputMatchForLines };

package/vscode/src/vs/workbench/api/browser/mainThreadTerminalShellIntegration.js

@@ -11,7 +11,12 @@ import { TerminalShellExecutionCommandLineConfidence } from '@codingame/monaco-v
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 
 let MainThreadTerminalShellIntegration = class MainThreadTerminalShellIntegration extends Disposable {
-    constructor(extHostContext, _terminalService, workbenchEnvironmentService, _extensionService) {
+    constructor(
+        extHostContext,
+        _terminalService,
+        workbenchEnvironmentService,
+        _extensionService
+    ) {
         super();
         this._terminalService = _terminalService;
         this._extensionService = _extensionService;
@@ -32,20 +37,26 @@ let MainThreadTerminalShellIntegration = class MainThreadTerminalShellIntegratio
             return ( Event.map(instance.capabilities.onDidAddCommandDetectionCapability, () => instance));
         })).event;
         this._store.add(onDidAddCommandDetection(e => this._enableShellIntegration(e)));
-        const cwdChangeEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CwdDetection, e => e.onDidChangeCwd));
+        const cwdChangeEvent = this._store.add(
+            this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CwdDetection, e => e.onDidChangeCwd)
+        );
         this._store.add(cwdChangeEvent.event(e => {
             this._proxy.$cwdChange(e.instance.instanceId, e.data);
         }));
-        const envChangeEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.ShellEnvDetection, e => e.onDidChangeEnv));
+        const envChangeEvent = this._store.add(
+            this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.ShellEnvDetection, e => e.onDidChangeEnv)
+        );
         this._store.add(envChangeEvent.event(e => {
-            if (e.data.value && typeof e.data.value === 'object') {
+            if (e.data.value && typeof e.data.value === "object") {
                 const envValue = e.data.value;
                 const keysArr = ( Object.keys(envValue));
                 const valuesArr = ( Object.values(envValue));
                 this._proxy.$shellEnvChange(e.instance.instanceId, keysArr, valuesArr, e.data.isTrusted);
             }
         }));
-        const commandDetectionStartEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CommandDetection, e => e.onCommandExecuted));
+        const commandDetectionStartEvent = this._store.add(
+            this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CommandDetection, e => e.onCommandExecuted)
+        );
         let currentCommand;
         this._store.add(commandDetectionStartEvent.event(e => {
             if (e.data === currentCommand) {
@@ -53,26 +64,46 @@ let MainThreadTerminalShellIntegration = class MainThreadTerminalShellIntegratio
             }
             currentCommand = e.data;
             const instanceId = e.instance.instanceId;
-            this._proxy.$shellExecutionStart(instanceId, instanceSupportsExecuteCommandApi(e.instance), e.data.command, convertToExtHostCommandLineConfidence(e.data), e.data.isTrusted, e.data.cwd);
+            this._proxy.$shellExecutionStart(
+                instanceId,
+                instanceSupportsExecuteCommandApi(e.instance),
+                e.data.command,
+                convertToExtHostCommandLineConfidence(e.data),
+                e.data.isTrusted,
+                e.data.cwd
+            );
             instanceDataListeners.get(instanceId)?.dispose();
-            instanceDataListeners.set(instanceId, Event.accumulate(e.instance.onData, 50, true, this._store)(events => {
-                this._proxy.$shellExecutionData(instanceId, events.join(''));
-            }));
+            instanceDataListeners.set(
+                instanceId,
+                Event.accumulate(e.instance.onData, 50, true, this._store)(events => {
+                    this._proxy.$shellExecutionData(instanceId, events.join(""));
+                })
+            );
         }));
-        const commandDetectionEndEvent = this._store.add(this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CommandDetection, e => e.onCommandFinished));
+        const commandDetectionEndEvent = this._store.add(
+            this._terminalService.createOnInstanceCapabilityEvent(TerminalCapability.CommandDetection, e => e.onCommandFinished)
+        );
         this._store.add(commandDetectionEndEvent.event(e => {
             currentCommand = undefined;
             const instanceId = e.instance.instanceId;
             instanceDataListeners.get(instanceId)?.dispose();
-            this._proxy.$shellExecutionEnd(instanceId, e.data.command, convertToExtHostCommandLineConfidence(e.data), e.data.isTrusted, e.data.exitCode);
+            this._proxy.$shellExecutionEnd(
+                instanceId,
+                e.data.command,
+                convertToExtHostCommandLineConfidence(e.data),
+                e.data.isTrusted,
+                e.data.exitCode
+            );
         }));
-        this._store.add(this._terminalService.onDidDisposeInstance(e => this._proxy.$closeTerminal(e.instanceId)));
+        this._store.add(
+            this._terminalService.onDidDisposeInstance(e => this._proxy.$closeTerminal(e.instanceId))
+        );
     }
     $executeCommand(terminalId, commandLine) {
         this._terminalService.getInstanceFromId(terminalId)?.runCommand(commandLine, true);
     }
     _enableShellIntegration(instance) {
-        this._extensionService.activateByEvent('onTerminalShellIntegration:*');
+        this._extensionService.activateByEvent("onTerminalShellIntegration:*");
         if (instance.shellType) {
             this._extensionService.activateByEvent(`onTerminalShellIntegration:${instance.shellType}`);
         }
@@ -91,17 +122,17 @@ MainThreadTerminalShellIntegration = __decorate([
 ], MainThreadTerminalShellIntegration);
 function convertToExtHostCommandLineConfidence(command) {
     switch (command.commandLineConfidence) {
-        case 'high':
-            return TerminalShellExecutionCommandLineConfidence.High;
-        case 'medium':
-            return TerminalShellExecutionCommandLineConfidence.Medium;
-        case 'low':
-        default:
-            return TerminalShellExecutionCommandLineConfidence.Low;
+    case "high":
+        return TerminalShellExecutionCommandLineConfidence.High;
+    case "medium":
+        return TerminalShellExecutionCommandLineConfidence.Medium;
+    case "low":
+    default:
+        return TerminalShellExecutionCommandLineConfidence.Low;
     }
 }
 function instanceSupportsExecuteCommandApi(instance) {
-    return instance.shellLaunchConfig.type !== 'Task';
+    return instance.shellLaunchConfig.type !== "Task";
 }
 
 export { MainThreadTerminalShellIntegration };