@codingame/monaco-vscode-xterm-common 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalProcessManager.d.ts

@@ -31,7 +31,7 @@ import { IAccessibilityService } from "@codingame/monaco-vscode-api/vscode/vs/pl
  *
  * Internal definitions:
  * - Process: The process launched with the terminalProcess.ts file, or the pty as a whole
- * - Pty Process: The pseudoterminal parent process (or the conpty/winpty agent process)
+ * - Pty Process: The pseudoterminal parent process (or the conpty agent process)
  * - Shell Process: The pseudoterminal child process (ie. the shell)
  */
 export declare class TerminalProcessManager extends Disposable implements ITerminalProcessManager {

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalProcessManager.js

@@ -44,24 +44,61 @@ import { BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/
 import { isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 
 var ProcessConstants;
-(function (ProcessConstants) {
+(function(ProcessConstants) {
     ProcessConstants[ProcessConstants["ErrorLaunchThresholdDuration"] = 500] = "ErrorLaunchThresholdDuration";
     ProcessConstants[ProcessConstants["LatencyMeasuringInterval"] = 1000] = "LatencyMeasuringInterval";
 })(ProcessConstants || (ProcessConstants = {}));
 var ProcessType;
-(function (ProcessType) {
+(function(ProcessType) {
     ProcessType[ProcessType["Process"] = 0] = "Process";
     ProcessType[ProcessType["PsuedoTerminal"] = 1] = "PsuedoTerminal";
 })(ProcessType || (ProcessType = {}));
 let TerminalProcessManager = class TerminalProcessManager extends Disposable {
-    get persistentProcessId() { return this._process?.id; }
-    get shouldPersist() { return !!this.reconnectionProperties || (this._process ? this._process.shouldPersist : false); }
-    get hasWrittenData() { return this._hasWrittenData; }
-    get hasChildProcesses() { return this._hasChildProcesses; }
-    get reconnectionProperties() { return this._shellLaunchConfig?.attachPersistentProcess?.reconnectionProperties || this._shellLaunchConfig?.reconnectionProperties || undefined; }
-    get extEnvironmentVariableCollection() { return this._extEnvironmentVariableCollection; }
-    get processTraits() { return this._processTraits; }
-    constructor(_instanceId, cwd, environmentVariableCollections, shellIntegrationNonce, _historyService, _instantiationService, _logService, _workspaceContextService, _configurationResolverService, _workbenchEnvironmentService, _productService, _remoteAgentService, _pathService, _environmentVariableService, _terminalConfigurationService, _terminalProfileResolverService, _configurationService, _terminalInstanceService, _telemetryService, _notificationService, _accessibilityService, _terminalService) {
+    get persistentProcessId() {
+        return this._process?.id;
+    }
+    get shouldPersist() {
+        return !!this.reconnectionProperties || (this._process ? this._process.shouldPersist : false);
+    }
+    get hasWrittenData() {
+        return this._hasWrittenData;
+    }
+    get hasChildProcesses() {
+        return this._hasChildProcesses;
+    }
+    get reconnectionProperties() {
+        return this._shellLaunchConfig?.attachPersistentProcess?.reconnectionProperties || this._shellLaunchConfig?.reconnectionProperties || undefined;
+    }
+    get extEnvironmentVariableCollection() {
+        return this._extEnvironmentVariableCollection;
+    }
+    get processTraits() {
+        return this._processTraits;
+    }
+    constructor(
+        _instanceId,
+        cwd,
+        environmentVariableCollections,
+        shellIntegrationNonce,
+        _historyService,
+        _instantiationService,
+        _logService,
+        _workspaceContextService,
+        _configurationResolverService,
+        _workbenchEnvironmentService,
+        _productService,
+        _remoteAgentService,
+        _pathService,
+        _environmentVariableService,
+        _terminalConfigurationService,
+        _terminalProfileResolverService,
+        _configurationService,
+        _terminalInstanceService,
+        _telemetryService,
+        _notificationService,
+        _accessibilityService,
+        _terminalService
+    ) {
         super();
         this._instanceId = _instanceId;
         this._historyService = _historyService;
@@ -93,7 +130,10 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
         this._hasChildProcesses = false;
         this._ptyListenersAttached = false;
         this._isDisconnected = false;
-        this._dimensions = { cols: 0, rows: 0 };
+        this._dimensions = {
+            cols: 0,
+            rows: 0
+        };
         this._onPtyDisconnect = this._register(( new Emitter()));
         this.onPtyDisconnect = this._onPtyDisconnect.event;
         this._onPtyReconnect = this._register(( new Emitter()));
@@ -122,25 +162,34 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
         this._dataFilter = this._register(this._instantiationService.createInstance(SeamlessRelaunchDataFilter));
         this._register(this._dataFilter.onProcessData(ev => {
             const data = (isString(ev) ? ev : ev.data);
-            const beforeProcessDataEvent = { data };
+            const beforeProcessDataEvent = {
+                data
+            };
             this._onBeforeProcessData.fire(beforeProcessDataEvent);
             if (beforeProcessDataEvent.data && beforeProcessDataEvent.data.length > 0) {
                 if (!isString(ev)) {
                     ev.data = beforeProcessDataEvent.data;
                 }
-                this._onProcessData.fire(!isString(ev) ? ev : { data: beforeProcessDataEvent.data, trackCommit: false });
+                this._onProcessData.fire(!isString(ev) ? ev : {
+                    data: beforeProcessDataEvent.data,
+                    trackCommit: false
+                });
             }
         }));
-        if (cwd && typeof cwd === 'object') {
+        if (cwd && typeof cwd === "object") {
             this.remoteAuthority = getRemoteAuthority(cwd);
-        }
-        else {
+        } else {
             this.remoteAuthority = this._workbenchEnvironmentService.remoteAuthority;
         }
         if (environmentVariableCollections) {
             this._extEnvironmentVariableCollection = ( new MergedEnvironmentVariableCollection(environmentVariableCollections));
-            this._register(this._environmentVariableService.onDidChangeCollections(newCollection => this._onEnvironmentVariableCollectionChange(newCollection)));
-            this.environmentVariableInfo = this._instantiationService.createInstance(EnvironmentVariableInfoChangesActive, this._extEnvironmentVariableCollection);
+            this._register(this._environmentVariableService.onDidChangeCollections(
+                newCollection => this._onEnvironmentVariableCollectionChange(newCollection)
+            ));
+            this.environmentVariableInfo = this._instantiationService.createInstance(
+                EnvironmentVariableInfoChangesActive,
+                this._extEnvironmentVariableCollection
+            );
             this._onEnvironmentVariableInfoChange.fire(this.environmentVariableInfo);
         }
         this.shellIntegrationNonce = shellIntegrationNonce ?? generateUuid();
@@ -150,14 +199,16 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
             if (this._process?.freePortKillProcess) {
                 await this._process?.freePortKillProcess(port);
             }
-        }
-        catch (e) {
-            this._notificationService.notify({ message: ( localize(
-                11638,
-                'Could not kill process listening on port {0}, command exited with error {1}',
-                port,
-                e
-            )), severity: Severity.Warning });
+        } catch (e) {
+            this._notificationService.notify({
+                message: ( localize(
+                    11962,
+                    "Could not kill process listening on port {0}, command exited with error {1}",
+                    port,
+                    e
+                )),
+                severity: Severity.Warning
+            });
         }
     }
     dispose(immediate = false) {
@@ -195,8 +246,7 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
         if (shellLaunchConfig.customPtyImplementation) {
             this._processType = ProcessType.PsuedoTerminal;
             newProcess = shellLaunchConfig.customPtyImplementation(this._instanceId, cols, rows);
-        }
-        else {
+        } else {
             const backend = await this._terminalInstanceService.getBackend(this.remoteAuthority);
             if (!backend) {
                 throw ( new Error(
@@ -204,7 +254,11 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
                 ));
             }
             this.backend = backend;
-            const variableResolver = createVariableResolver(this._cwdWorkspaceFolder, await this._terminalProfileResolverService.getEnvironment(this.remoteAuthority), this._configurationResolverService);
+            const variableResolver = createVariableResolver(
+                this._cwdWorkspaceFolder,
+                await this._terminalProfileResolverService.getEnvironment(this.remoteAuthority),
+                this._configurationResolverService
+            );
             this.userHome = this._pathService.resolvedUserHome?.fsPath;
             this.os = OS;
             if (!!this.remoteAuthority) {
@@ -224,9 +278,11 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
                     const result = await backend.attachToProcess(shellLaunchConfig.attachPersistentProcess.id);
                     if (result) {
                         newProcess = result;
-                    }
-                    else {
-                        this._logService.warn(`Attach to process failed for terminal`, shellLaunchConfig.attachPersistentProcess);
+                    } else {
+                        this._logService.warn(
+                            `Attach to process failed for terminal`,
+                            shellLaunchConfig.attachPersistentProcess
+                        );
                         shellLaunchConfig.attachPersistentProcess = undefined;
                     }
                 }
@@ -241,19 +297,17 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
                             suggestEnabled: this._configurationService.getValue(TerminalContribSettingId.SuggestEnabled),
                             nonce: this.shellIntegrationNonce
                         },
-                        windowsEnableConpty: this._terminalConfigurationService.config.windowsEnableConpty,
                         windowsUseConptyDll: this._terminalConfigurationService.config.windowsUseConptyDll ?? false,
                         environmentVariableCollections: this._extEnvironmentVariableCollection?.collections ? serializeEnvironmentVariableCollections(this._extEnvironmentVariableCollection.collections) : undefined,
                         workspaceFolder: this._cwdWorkspaceFolder,
                         isScreenReaderOptimized: this._accessibilityService.isScreenReaderOptimized()
                     };
                     try {
-                        newProcess = await backend.createProcess(shellLaunchConfig, '',
+                        newProcess = await backend.createProcess(shellLaunchConfig, "",
                         cols, rows, this._terminalConfigurationService.config.unicodeVersion, env,
                         options, shouldPersist);
-                    }
-                    catch (e) {
-                        if (e?.message === 'Could not fetch remote environment') {
+                    } catch (e) {
+                        if (e?.message === "Could not fetch remote environment") {
                             this._logService.trace(`Could not fetch remote environment, silently failing`);
                             return undefined;
                         }
@@ -263,15 +317,16 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
                 if (!this._isDisposed) {
                     this._setupPtyHostListeners(backend);
                 }
-            }
-            else {
+            } else {
                 if (shellLaunchConfig.attachPersistentProcess) {
                     const result = shellLaunchConfig.attachPersistentProcess.findRevivedId ? await backend.attachToRevivedProcess(shellLaunchConfig.attachPersistentProcess.id) : await backend.attachToProcess(shellLaunchConfig.attachPersistentProcess.id);
                     if (result) {
                         newProcess = result;
-                    }
-                    else {
-                        this._logService.warn(`Attach to process failed for terminal`, shellLaunchConfig.attachPersistentProcess);
+                    } else {
+                        this._logService.warn(
+                            `Attach to process failed for terminal`,
+                            shellLaunchConfig.attachPersistentProcess
+                        );
                         shellLaunchConfig.attachPersistentProcess = undefined;
                     }
                 }
@@ -296,34 +351,43 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
         if (this._processListeners) {
             dispose(this._processListeners);
         }
-        this._processListeners = [
-            newProcess.onProcessReady((e) => {
-                this._processTraits = e;
-                this.shellProcessId = e.pid;
-                this._initialCwd = e.cwd;
-                this.processReadyTimestamp = Date.now();
-                this._onDidChangeProperty.fire({ type: ProcessPropertyType.InitialCwd, value: this._initialCwd });
-                this._onProcessReady.fire(e);
-                if (this._preLaunchInputQueue.length > 0 && this._process) {
-                    newProcess.input(this._preLaunchInputQueue.join(''));
-                    this._preLaunchInputQueue.length = 0;
-                }
-            }),
-            newProcess.onProcessExit(exitCode => this._onExit(exitCode)),
-            newProcess.onDidChangeProperty(({ type, value }) => {
-                switch (type) {
-                    case ProcessPropertyType.HasChildProcesses:
-                        this._hasChildProcesses = value;
-                        break;
-                    case ProcessPropertyType.FailedShellIntegrationActivation:
-                        this._telemetryService?.publicLog2('terminal/shellIntegrationActivationFailureCustomArgs');
-                        break;
-                }
-                this._onDidChangeProperty.fire({ type, value });
-            })
-        ];
+        this._processListeners = [newProcess.onProcessReady(e => {
+            this._processTraits = e;
+            this.shellProcessId = e.pid;
+            this._initialCwd = e.cwd;
+            this.processReadyTimestamp = Date.now();
+            this._onDidChangeProperty.fire({
+                type: ProcessPropertyType.InitialCwd,
+                value: this._initialCwd
+            });
+            this._onProcessReady.fire(e);
+            if (this._preLaunchInputQueue.length > 0 && this._process) {
+                newProcess.input(this._preLaunchInputQueue.join(""));
+                this._preLaunchInputQueue.length = 0;
+            }
+        }), newProcess.onProcessExit(exitCode => this._onExit(exitCode)), newProcess.onDidChangeProperty((
+            {
+                type,
+                value
+            }
+        ) => {
+            switch (type) {
+            case ProcessPropertyType.HasChildProcesses:
+                this._hasChildProcesses = value;
+                break;
+            case ProcessPropertyType.FailedShellIntegrationActivation:
+                this._telemetryService?.publicLog2("terminal/shellIntegrationActivationFailureCustomArgs");
+                break;
+            }
+            this._onDidChangeProperty.fire({
+                type,
+                value
+            });
+        })];
         if (newProcess.onProcessReplayComplete) {
-            this._processListeners.push(newProcess.onProcessReplayComplete(() => this._onProcessReplayComplete.fire()));
+            this._processListeners.push(
+                newProcess.onProcessReplayComplete(() => this._onProcessReplayComplete.fire())
+            );
         }
         if (newProcess.onRestoreCommands) {
             this._processListeners.push(newProcess.onRestoreCommands(e => this._onRestoreCommands.fire(e)));
@@ -339,7 +403,9 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
         }
         runWhenWindowIdle(getActiveWindow(), () => {
             this.backend?.getLatency().then(measurements => {
-                this._logService.info(`Latency measurements for ${this.remoteAuthority ?? 'local'} backend\n${( measurements.map(e => `${e.label}: ${e.latency.toFixed(2)}ms`)).join('\n')}`);
+                this._logService.info(
+                    `Latency measurements for ${this.remoteAuthority ?? "local"} backend\n${( measurements.map(e => `${e.label}: ${e.latency.toFixed(2)}ms`)).join("\n")}`
+                );
             });
         });
         return undefined;
@@ -356,26 +422,41 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
     }
     async _resolveEnvironment(backend, variableResolver, shellLaunchConfig) {
         const workspaceFolder = getWorkspaceForTerminal(shellLaunchConfig.cwd, this._workspaceContextService, this._historyService);
-        const platformKey = isWindows ? 'windows' : (isMacintosh ? 'osx' : 'linux');
+        const platformKey = isWindows ? "windows" : (isMacintosh ? "osx" : "linux");
         const envFromConfigValue = this._configurationService.getValue(`terminal.integrated.env.${platformKey}`);
         let baseEnv;
         if (shellLaunchConfig.useShellEnvironment) {
             const shellEnv = await backend.getShellEnvironment();
             if (!shellEnv) {
-                throw ( new BugIndicatingError('Cannot fetch shell environment to use'));
+                throw ( new BugIndicatingError("Cannot fetch shell environment to use"));
             }
             baseEnv = shellEnv;
-        }
-        else {
+        } else {
             baseEnv = await this._terminalProfileResolverService.getEnvironment(this.remoteAuthority);
         }
-        const env = await createTerminalEnvironment(shellLaunchConfig, envFromConfigValue, variableResolver, this._productService.version, this._terminalConfigurationService.config.detectLocale, baseEnv);
+        const env = await createTerminalEnvironment(
+            shellLaunchConfig,
+            envFromConfigValue,
+            variableResolver,
+            this._productService.version,
+            this._terminalConfigurationService.config.detectLocale,
+            baseEnv
+        );
         if (!this._isDisposed && shouldUseEnvironmentVariableCollection(shellLaunchConfig)) {
             this._extEnvironmentVariableCollection = this._environmentVariableService.mergedCollection;
-            this._register(this._environmentVariableService.onDidChangeCollections(newCollection => this._onEnvironmentVariableCollectionChange(newCollection)));
-            await this._extEnvironmentVariableCollection.applyToProcessEnvironment(env, { workspaceFolder }, variableResolver);
-            if (this._extEnvironmentVariableCollection.getVariableMap({ workspaceFolder }).size) {
-                this.environmentVariableInfo = this._instantiationService.createInstance(EnvironmentVariableInfoChangesActive, this._extEnvironmentVariableCollection);
+            this._register(this._environmentVariableService.onDidChangeCollections(
+                newCollection => this._onEnvironmentVariableCollectionChange(newCollection)
+            ));
+            await this._extEnvironmentVariableCollection.applyToProcessEnvironment(env, {
+                workspaceFolder
+            }, variableResolver);
+            if (this._extEnvironmentVariableCollection.getVariableMap({
+                workspaceFolder
+            }).size) {
+                this.environmentVariableInfo = this._instantiationService.createInstance(
+                    EnvironmentVariableInfoChangesActive,
+                    this._extEnvironmentVariableCollection
+                );
                 this._onEnvironmentVariableInfoChange.fire(this.environmentVariableInfo);
             }
         }
@@ -387,7 +468,14 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
             os: OS
         });
         const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot(Schemas.file);
-        const initialCwd = await getCwd(shellLaunchConfig, userHome, variableResolver, activeWorkspaceRootUri, this._terminalConfigurationService.config.cwd, this._logService);
+        const initialCwd = await getCwd(
+            shellLaunchConfig,
+            userHome,
+            variableResolver,
+            activeWorkspaceRootUri,
+            this._terminalConfigurationService.config.cwd,
+            this._logService
+        );
         const env = await this._resolveEnvironment(backend, variableResolver, shellLaunchConfig);
         const options = {
             shellIntegration: {
@@ -395,14 +483,22 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
                 suggestEnabled: this._configurationService.getValue(TerminalContribSettingId.SuggestEnabled),
                 nonce: this.shellIntegrationNonce
             },
-            windowsEnableConpty: this._terminalConfigurationService.config.windowsEnableConpty,
             windowsUseConptyDll: this._terminalConfigurationService.config.windowsUseConptyDll ?? false,
             environmentVariableCollections: this._extEnvironmentVariableCollection ? serializeEnvironmentVariableCollections(this._extEnvironmentVariableCollection.collections) : undefined,
             workspaceFolder: this._cwdWorkspaceFolder,
             isScreenReaderOptimized: this._accessibilityService.isScreenReaderOptimized()
         };
         const shouldPersist = ((this._configurationService.getValue(TaskSettingId.Reconnection) && shellLaunchConfig.reconnectionProperties) || !shellLaunchConfig.isFeatureTerminal) && this._terminalConfigurationService.config.enablePersistentSessions && !shellLaunchConfig.isTransient;
-        return await backend.createProcess(shellLaunchConfig, initialCwd, cols, rows, this._terminalConfigurationService.config.unicodeVersion, env, options, shouldPersist);
+        return await backend.createProcess(
+            shellLaunchConfig,
+            initialCwd,
+            cols,
+            rows,
+            this._terminalConfigurationService.config.unicodeVersion,
+            env,
+            options,
+            shouldPersist
+        );
     }
     _setupPtyHostListeners(backend) {
         if (this._ptyListenersAttached) {
@@ -428,17 +524,29 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
             if (this._shellLaunchConfig) {
                 if (this._shellLaunchConfig.isFeatureTerminal && !this.reconnectionProperties) {
                     this._onExit(-1);
-                }
-                else {
+                } else {
                     const message = ( localize(
-                        11639,
+                        11963,
                         "Restarting the terminal because the connection to the shell process was lost..."
                     ));
-                    this._onProcessData.fire({ data: formatMessageForTerminal(message, { loudFormatting: true }), trackCommit: false });
-                    await this.relaunch(this._shellLaunchConfig, this._dimensions.cols, this._dimensions.rows, false);
+                    this._onProcessData.fire({
+                        data: formatMessageForTerminal(message, {
+                            loudFormatting: true
+                        }),
+                        trackCommit: false
+                    });
+                    await this.relaunch(
+                        this._shellLaunchConfig,
+                        this._dimensions.cols,
+                        this._dimensions.rows,
+                        false
+                    );
                 }
             }
         }));
+        this._register(toDisposable(() => {
+            this.ptyProcessReady = undefined;
+        }));
     }
     async getBackendOS() {
         let os = OS;
@@ -477,10 +585,9 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
         }
         try {
             this._process.resize(cols, rows);
-        }
-        catch (error) {
-            if (error.code !== 'EPIPE' && error.code !== 'ERR_IPC_CHANNEL_CLOSED') {
-                throw (error);
+        } catch (error) {
+            if (error.code !== "EPIPE" && error.code !== "ERR_IPC_CHANNEL_CLOSED") {
+                throw error;
             }
         }
         this._dimensions.cols = cols;
@@ -494,8 +601,7 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
             if (this._process) {
                 this._process.input(data);
             }
-        }
-        else {
+        } else {
             this._preLaunchInputQueue.push(data);
         }
     }
@@ -512,11 +618,11 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
         this._process?.processBinary(data);
     }
     get initialCwd() {
-        return this._initialCwd ?? '';
+        return this._initialCwd ?? "";
     }
     async refreshProperty(type) {
         if (!this._process) {
-            throw ( new Error('Cannot refresh property when process is not set'));
+            throw ( new Error("Cannot refresh property when process is not set"));
         }
         return this._process.refreshProperty(type);
     }
@@ -541,10 +647,15 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
         this._onProcessStateChange.fire();
     }
     _onEnvironmentVariableCollectionChange(newCollection) {
-        const diff = this._extEnvironmentVariableCollection.diff(newCollection, { workspaceFolder: this._cwdWorkspaceFolder });
+        const diff = this._extEnvironmentVariableCollection.diff(newCollection, {
+            workspaceFolder: this._cwdWorkspaceFolder
+        });
         if (diff === undefined) {
             if (this.environmentVariableInfo instanceof EnvironmentVariableInfoStale) {
-                this.environmentVariableInfo = this._instantiationService.createInstance(EnvironmentVariableInfoChangesActive, this._extEnvironmentVariableCollection);
+                this.environmentVariableInfo = this._instantiationService.createInstance(
+                    EnvironmentVariableInfoChangesActive,
+                    this._extEnvironmentVariableCollection
+                );
                 this._onEnvironmentVariableInfoChange.fire(this.environmentVariableInfo);
             }
             return;
@@ -556,26 +667,7 @@ let TerminalProcessManager = class TerminalProcessManager extends Disposable {
         this._process?.clearBuffer?.();
     }
 };
-TerminalProcessManager = ( __decorate([
-    ( __param(4, IHistoryService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, ITerminalLogService)),
-    ( __param(7, IWorkspaceContextService)),
-    ( __param(8, IConfigurationResolverService)),
-    ( __param(9, IWorkbenchEnvironmentService)),
-    ( __param(10, IProductService)),
-    ( __param(11, IRemoteAgentService)),
-    ( __param(12, IPathService)),
-    ( __param(13, IEnvironmentVariableService)),
-    ( __param(14, ITerminalConfigurationService)),
-    ( __param(15, ITerminalProfileResolverService)),
-    ( __param(16, IConfigurationService)),
-    ( __param(17, ITerminalInstanceService)),
-    ( __param(18, ITelemetryService)),
-    ( __param(19, INotificationService)),
-    ( __param(20, IAccessibilityService)),
-    ( __param(21, ITerminalService))
-], TerminalProcessManager));
+TerminalProcessManager = ( __decorate([( __param(4, IHistoryService)), ( __param(5, IInstantiationService)), ( __param(6, ITerminalLogService)), ( __param(7, IWorkspaceContextService)), ( __param(8, IConfigurationResolverService)), ( __param(9, IWorkbenchEnvironmentService)), ( __param(10, IProductService)), ( __param(11, IRemoteAgentService)), ( __param(12, IPathService)), ( __param(13, IEnvironmentVariableService)), ( __param(14, ITerminalConfigurationService)), ( __param(15, ITerminalProfileResolverService)), ( __param(16, IConfigurationService)), ( __param(17, ITerminalInstanceService)), ( __param(18, ITelemetryService)), ( __param(19, INotificationService)), ( __param(20, IAccessibilityService)), ( __param(21, ITerminalService))], TerminalProcessManager));
 class AckDataBufferer {
     constructor(_callback) {
         this._callback = _callback;
@@ -590,12 +682,14 @@ class AckDataBufferer {
     }
 }
 var SeamlessRelaunchConstants;
-(function (SeamlessRelaunchConstants) {
+(function(SeamlessRelaunchConstants) {
     SeamlessRelaunchConstants[SeamlessRelaunchConstants["RecordTerminalDuration"] = 10000] = "RecordTerminalDuration";
     SeamlessRelaunchConstants[SeamlessRelaunchConstants["SwapWaitMaximumDuration"] = 3000] = "SwapWaitMaximumDuration";
 })(SeamlessRelaunchConstants || (SeamlessRelaunchConstants = {}));
 let SeamlessRelaunchDataFilter = class SeamlessRelaunchDataFilter extends Disposable {
-    get onProcessData() { return this._onProcessData.event; }
+    get onProcessData() {
+        return this._onProcessData.event;
+    }
     constructor(_logService) {
         super();
         this._logService = _logService;
@@ -612,7 +706,7 @@ let SeamlessRelaunchDataFilter = class SeamlessRelaunchDataFilter extends Dispos
         if (!this._firstRecorder || !reset || this._disableSeamlessRelaunch) {
             [this._firstRecorder, this._firstDisposable.value] = this._createRecorder(process);
             if (this._disableSeamlessRelaunch && reset) {
-                this._onProcessData.fire('\x1bc');
+                this._onProcessData.fire("\u001bc");
             }
             this._dataListener.value = process.onProcessData(e => this._onProcessData.fire(e));
             this._disableSeamlessRelaunch = false;
@@ -621,7 +715,10 @@ let SeamlessRelaunchDataFilter = class SeamlessRelaunchDataFilter extends Dispos
         if (this._secondRecorder) {
             this.triggerSwap();
         }
-        this._swapTimeout = mainWindow.setTimeout(() => this.triggerSwap(), SeamlessRelaunchConstants.SwapWaitMaximumDuration);
+        this._swapTimeout = mainWindow.setTimeout(
+            () => this.triggerSwap(),
+            SeamlessRelaunchConstants.SwapWaitMaximumDuration
+        );
         this._dataListener.clear();
         this._firstDisposable.clear();
         const recorder = this._createRecorder(process);
@@ -649,10 +746,12 @@ let SeamlessRelaunchDataFilter = class SeamlessRelaunchDataFilter extends Dispos
         const secondData = this._getDataFromRecorder(this._secondRecorder);
         if (firstData === secondData) {
             this._logService.trace(`Seamless terminal relaunch - identical content`);
-        }
-        else {
+        } else {
             this._logService.trace(`Seamless terminal relaunch - resetting content`);
-            this._onProcessData.fire({ data: `\x1bc${secondData}`, trackCommit: false });
+            this._onProcessData.fire({
+                data: `\x1bc${secondData}`,
+                trackCommit: false
+            });
         }
         this._dataListener.value = this._activeProcess.onProcessData(e => this._onProcessData.fire(e));
         this._firstRecorder = this._secondRecorder;
@@ -674,11 +773,9 @@ let SeamlessRelaunchDataFilter = class SeamlessRelaunchDataFilter extends Dispos
         return [recorder, disposable];
     }
     _getDataFromRecorder(recorder) {
-        return ( recorder.generateReplayEventSync().events.filter(e => !!e.data).map(e => e.data)).join('');
+        return ( recorder.generateReplayEventSync().events.filter(e => !!e.data).map(e => e.data)).join("");
     }
 };
-SeamlessRelaunchDataFilter = ( __decorate([
-    ( __param(0, ITerminalLogService))
-], SeamlessRelaunchDataFilter));
+SeamlessRelaunchDataFilter = ( __decorate([( __param(0, ITerminalLogService))], SeamlessRelaunchDataFilter));
 
 export { TerminalProcessManager };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalResizeDebouncer.js

@@ -5,11 +5,17 @@ import { debounce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/dec
 import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 
 var Constants;
-(function (Constants) {
+(function(Constants) {
     Constants[Constants["StartDebouncingThreshold"] = 200] = "StartDebouncingThreshold";
 })(Constants || (Constants = {}));
 class TerminalResizeDebouncer extends Disposable {
-    constructor(_isVisible, _getXterm, _resizeBothCallback, _resizeXCallback, _resizeYCallback) {
+    constructor(
+        _isVisible,
+        _getXterm,
+        _resizeBothCallback,
+        _resizeXCallback,
+        _resizeYCallback
+    ) {
         super();
         this._isVisible = _isVisible;
         this._getXterm = _getXterm;
@@ -61,8 +67,11 @@ class TerminalResizeDebouncer extends Disposable {
         this._resizeXCallback(cols);
     }
 }
-TerminalResizeDebouncer.__decorator = ( __decorate([
-    debounce(100)
-], TerminalResizeDebouncer.prototype, "_debounceResizeX", null));
+TerminalResizeDebouncer.__decorator = ( __decorate(
+    [debounce(100)],
+    TerminalResizeDebouncer.prototype,
+    "_debounceResizeX",
+    null
+));
 
 export { TerminalResizeDebouncer };