@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

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

@@ -1,2101 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { isFirefox } from 'monaco-editor/esm/vs/base/browser/browser.js';
-import { BrowserFeatures } from 'monaco-editor/esm/vs/base/browser/canIUse.js';
-import { DataTransfers } from 'monaco-editor/esm/vs/base/browser/dnd.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
-import { DomScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js';
-import { AutoOpenBarrier, Promises, timeout } from 'monaco-editor/esm/vs/base/common/async.js';
-import { Codicon, getAllCodicons } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
-import { onUnexpectedError, ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { template } from 'monaco-editor/esm/vs/base/common/labels.js';
-import { Disposable, MutableDisposable, toDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import * as path from 'monaco-editor/esm/vs/base/common/path.js';
-import { OS, isMacintosh, isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { TabFocus } from 'monaco-editor/esm/vs/editor/browser/config/tabFocus.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
-import { AudioCue, IAudioCueService } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
-import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { containsDragType, CodeDataTransfers } from 'monaco-editor/esm/vs/platform/dnd/browser/dnd.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
-import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { TerminalCapabilityStoreMultiplexer } from '../../../../platform/terminal/common/capabilities/terminalCapabilityStore.js';
-import { deserializeEnvironmentVariableCollections } from '../../../../platform/terminal/common/environmentVariableShared.js';
-import { TitleEventSource, TerminalLocation, TerminalExitReason, ITerminalLogService } from '../../../../platform/terminal/common/terminal.js';
-import { formatMessageForTerminal } from '../../../../platform/terminal/common/terminalStrings.js';
-import { editorBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { getIconRegistry } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { IWorkspaceTrustRequestService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
-import { PANEL_BACKGROUND, SIDE_BAR_BACKGROUND } from '../../../common/theme.js';
-import { IViewsService, IViewDescriptorService } from '../../../common/views.js';
-import { TerminalLaunchHelpAction } from './terminalActions.js';
-import { TerminalEditorInput } from './terminalEditorInput.js';
-import { TerminalExtensionsRegistry } from './terminalExtensions.js';
-import { getStandardColors, getColorStyleElement, getColorClass } from './terminalIcon.js';
-import { TerminalProcessManager } from './terminalProcessManager.js';
-import { showRunRecentQuickPick } from './terminalRunRecentQuickPick.js';
-import { TerminalStatusList } from './terminalStatusList.js';
-import { getTerminalUri, getTerminalResourcesFromDragEvent } from './terminalUri.js';
-import { TerminalWidgetManager } from './widgets/widgetManager.js';
-import { LineDataEventAddon } from './xterm/lineDataEventAddon.js';
-import { XtermTerminal, getXtermScaledDimensions } from './xterm/xtermTerminal.js';
-import { getDirectoryHistory, getCommandHistory } from '../common/history.js';
-import { TERMINAL_VIEW_ID, TERMINAL_CREATION_COMMANDS, DEFAULT_COMMANDS_TO_SKIP_SHELL, ITerminalProfileResolverService } from '../common/terminal.js';
-import { TERMINAL_BACKGROUND_COLOR } from '../common/terminalColorRegistry.js';
-import { TerminalContextKeys } from '../common/terminalContextKey.js';
-import { preparePathForShell, getWorkspaceForTerminal } from '../common/terminalEnvironment.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
-import { IHistoryService } from '../../../services/history/common/history.js';
-import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
-import { IPathService } from '../../../services/path/common/pathService.js';
-import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
-import { Terminal } from 'xterm';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-var TerminalInstance_1;
-let xtermConstructor;
-const shellIntegrationSupportedShellTypes = [
-    "bash" ,
-    "zsh" ,
-    "pwsh" ,
-    "pwsh"
-];
-let TerminalInstance = class TerminalInstance extends Disposable {
-    static { TerminalInstance_1 = this; }
-    static { this._instanceIdCounter = 1; }
-    get domElement() { return this._wrapperElement; }
-    get usedShellIntegrationInjection() { return this._usedShellIntegrationInjection; }
-    get extEnvironmentVariableCollection() { return this._processManager.extEnvironmentVariableCollection; }
-    get waitOnExit() { return this._shellLaunchConfig.attachPersistentProcess?.waitOnExit || this._shellLaunchConfig.waitOnExit; }
-    set waitOnExit(value) {
-        this._shellLaunchConfig.waitOnExit = value;
-    }
-    get target() { return this._target; }
-    set target(value) { this._target = value; }
-    get instanceId() { return this._instanceId; }
-    get resource() { return this._resource; }
-    get cols() {
-        if (this._fixedCols !== undefined) {
-            return this._fixedCols;
-        }
-        if (this._dimensionsOverride && this._dimensionsOverride.cols) {
-            if (this._dimensionsOverride.forceExactSize) {
-                return this._dimensionsOverride.cols;
-            }
-            return Math.min(Math.max(this._dimensionsOverride.cols, 2), this._cols);
-        }
-        return this._cols;
-    }
-    get rows() {
-        if (this._fixedRows !== undefined) {
-            return this._fixedRows;
-        }
-        if (this._dimensionsOverride && this._dimensionsOverride.rows) {
-            if (this._dimensionsOverride.forceExactSize) {
-                return this._dimensionsOverride.rows;
-            }
-            return Math.min(Math.max(this._dimensionsOverride.rows, 2), this._rows);
-        }
-        return this._rows;
-    }
-    get isDisposed() { return this._isDisposed; }
-    get fixedCols() { return this._fixedCols; }
-    get fixedRows() { return this._fixedRows; }
-    get maxCols() { return this._cols; }
-    get maxRows() { return this._rows; }
-    get processId() { return this._processManager.shellProcessId; }
-    get processReady() { return this._processManager.ptyProcessReady; }
-    get hasChildProcesses() { return this.shellLaunchConfig.attachPersistentProcess?.hasChildProcesses || this._processManager.hasChildProcesses; }
-    get reconnectionProperties() { return this.shellLaunchConfig.attachPersistentProcess?.reconnectionProperties || this.shellLaunchConfig.reconnectionProperties; }
-    get areLinksReady() { return this._areLinksReady; }
-    get initialDataEvents() { return this._initialDataEvents; }
-    get exitCode() { return this._exitCode; }
-    get exitReason() { return this._exitReason; }
-    get hadFocusOnExit() { return this._hadFocusOnExit; }
-    get isTitleSetByProcess() { return !!this._messageTitleDisposable.value; }
-    get shellLaunchConfig() { return this._shellLaunchConfig; }
-    get shellType() { return this._shellType; }
-    get os() { return this._processManager.os; }
-    get isRemote() { return this._processManager.remoteAuthority !== undefined; }
-    get remoteAuthority() { return this._processManager.remoteAuthority; }
-    get hasFocus() { return this._wrapperElement.contains(document.activeElement) ?? false; }
-    get title() { return this._title; }
-    get titleSource() { return this._titleSource; }
-    get icon() { return this._getIcon(); }
-    get color() { return this._getColor(); }
-    get processName() { return this._processName; }
-    get sequence() { return this._sequence; }
-    get staticTitle() { return this._staticTitle; }
-    get workspaceFolder() { return this._workspaceFolder; }
-    get cwd() { return this._cwd; }
-    get initialCwd() { return this._initialCwd; }
-    get description() {
-        if (this._description) {
-            return this._description;
-        }
-        const type = this.shellLaunchConfig.attachPersistentProcess?.type || this.shellLaunchConfig.type;
-        if (type) {
-            if (type === 'Task') {
-                return ( nls.localize('terminalTypeTask', "Task"));
-            }
-            return ( nls.localize('terminalTypeLocal', "Local"));
-        }
-        return undefined;
-    }
-    get userHome() { return this._userHome; }
-    get shellIntegrationNonce() { return this._processManager.shellIntegrationNonce; }
-    get injectedArgs() { return this._injectedArgs; }
-    constructor(_terminalShellTypeContextKey, _terminalInRunCommandPicker, _terminalSuggestWidgetVisibleContextKey, _configHelper, _shellLaunchConfig, _contextKeyService, instantiationService, _terminalProfileResolverService, _pathService, _keybindingService, _notificationService, _preferencesService, _viewsService, _clipboardService, _themeService, _configurationService, _logService, _dialogService, _storageService, _accessibilityService, _productService, _quickInputService, workbenchEnvironmentService, _workspaceContextService, _editorService, _workspaceTrustRequestService, _historyService, _telemetryService, _openerService, _commandService, _audioCueService, _viewDescriptorService) {
-        super();
-        this._terminalShellTypeContextKey = _terminalShellTypeContextKey;
-        this._terminalInRunCommandPicker = _terminalInRunCommandPicker;
-        this._terminalSuggestWidgetVisibleContextKey = _terminalSuggestWidgetVisibleContextKey;
-        this._configHelper = _configHelper;
-        this._shellLaunchConfig = _shellLaunchConfig;
-        this._contextKeyService = _contextKeyService;
-        this._terminalProfileResolverService = _terminalProfileResolverService;
-        this._pathService = _pathService;
-        this._keybindingService = _keybindingService;
-        this._notificationService = _notificationService;
-        this._preferencesService = _preferencesService;
-        this._viewsService = _viewsService;
-        this._clipboardService = _clipboardService;
-        this._themeService = _themeService;
-        this._configurationService = _configurationService;
-        this._logService = _logService;
-        this._dialogService = _dialogService;
-        this._storageService = _storageService;
-        this._accessibilityService = _accessibilityService;
-        this._productService = _productService;
-        this._quickInputService = _quickInputService;
-        this._workspaceContextService = _workspaceContextService;
-        this._editorService = _editorService;
-        this._workspaceTrustRequestService = _workspaceTrustRequestService;
-        this._historyService = _historyService;
-        this._telemetryService = _telemetryService;
-        this._openerService = _openerService;
-        this._commandService = _commandService;
-        this._audioCueService = _audioCueService;
-        this._viewDescriptorService = _viewDescriptorService;
-        this._contributions = ( new Map());
-        this._latestXtermWriteData = 0;
-        this._latestXtermParseData = 0;
-        this._title = '';
-        this._titleSource = TitleEventSource.Process;
-        this._cols = 0;
-        this._rows = 0;
-        this._cwd = undefined;
-        this._initialCwd = undefined;
-        this._injectedArgs = undefined;
-        this._layoutSettingsChanged = true;
-        this._areLinksReady = false;
-        this._initialDataEvents = [];
-        this._messageTitleDisposable = this._register(( new MutableDisposable()));
-        this._widgetManager = ( new TerminalWidgetManager());
-        this._dndObserver = this._register(( new MutableDisposable()));
-        this._processName = '';
-        this._usedShellIntegrationInjection = false;
-        this.capabilities = ( new TerminalCapabilityStoreMultiplexer());
-        this.disableLayout = false;
-        this._onExit = ( new Emitter());
-        this.onExit = this._onExit.event;
-        this._onDisposed = this._register(( new Emitter()));
-        this.onDisposed = this._onDisposed.event;
-        this._onProcessIdReady = this._register(( new Emitter()));
-        this.onProcessIdReady = this._onProcessIdReady.event;
-        this._onProcessReplayComplete = this._register(( new Emitter()));
-        this.onProcessReplayComplete = this._onProcessReplayComplete.event;
-        this._onTitleChanged = this._register(( new Emitter()));
-        this.onTitleChanged = this._onTitleChanged.event;
-        this._onIconChanged = this._register(( new Emitter()));
-        this.onIconChanged = this._onIconChanged.event;
-        this._onData = this._register(( new Emitter()));
-        this.onData = this._onData.event;
-        this._onBinary = this._register(( new Emitter()));
-        this.onBinary = this._onBinary.event;
-        this._onLineData = this._register(( new Emitter({
-            onDidAddFirstListener: () => this._onLineDataSetup()
-        })));
-        this.onLineData = this._onLineData.event;
-        this._onRequestExtHostProcess = this._register(( new Emitter()));
-        this.onRequestExtHostProcess = this._onRequestExtHostProcess.event;
-        this._onDimensionsChanged = this._register(( new Emitter()));
-        this.onDimensionsChanged = this._onDimensionsChanged.event;
-        this._onMaximumDimensionsChanged = this._register(( new Emitter()));
-        this.onMaximumDimensionsChanged = this._onMaximumDimensionsChanged.event;
-        this._onDidFocus = this._register(( new Emitter()));
-        this.onDidFocus = this._onDidFocus.event;
-        this._onDidRequestFocus = this._register(( new Emitter()));
-        this.onDidRequestFocus = this._onDidRequestFocus.event;
-        this._onDidBlur = this._register(( new Emitter()));
-        this.onDidBlur = this._onDidBlur.event;
-        this._onDidInputData = this._register(( new Emitter()));
-        this.onDidInputData = this._onDidInputData.event;
-        this._onDidChangeSelection = this._register(( new Emitter()));
-        this.onDidChangeSelection = this._onDidChangeSelection.event;
-        this._onRequestAddInstanceToGroup = this._register(( new Emitter()));
-        this.onRequestAddInstanceToGroup = this._onRequestAddInstanceToGroup.event;
-        this._onDidChangeHasChildProcesses = this._register(( new Emitter()));
-        this.onDidChangeHasChildProcesses = this._onDidChangeHasChildProcesses.event;
-        this._onDidRunText = this._register(( new Emitter()));
-        this.onDidRunText = this._onDidRunText.event;
-        this._wrapperElement = document.createElement('div');
-        this._wrapperElement.classList.add('terminal-wrapper');
-        this._skipTerminalCommands = [];
-        this._isExiting = false;
-        this._hadFocusOnExit = false;
-        this._isVisible = false;
-        this._isDisposed = false;
-        this._instanceId = TerminalInstance_1._instanceIdCounter++;
-        this._hasHadInput = false;
-        this._fixedRows = _shellLaunchConfig.attachPersistentProcess?.fixedDimensions?.rows;
-        this._fixedCols = _shellLaunchConfig.attachPersistentProcess?.fixedDimensions?.cols;
-        this._resource = getTerminalUri(this._workspaceContextService.getWorkspace().id, this.instanceId, this.title);
-        if (this._shellLaunchConfig.attachPersistentProcess?.hideFromUser) {
-            this._shellLaunchConfig.hideFromUser = this._shellLaunchConfig.attachPersistentProcess.hideFromUser;
-        }
-        if (this._shellLaunchConfig.attachPersistentProcess?.isFeatureTerminal) {
-            this._shellLaunchConfig.isFeatureTerminal = this._shellLaunchConfig.attachPersistentProcess.isFeatureTerminal;
-        }
-        if (this._shellLaunchConfig.attachPersistentProcess?.type) {
-            this._shellLaunchConfig.type = this._shellLaunchConfig.attachPersistentProcess.type;
-        }
-        if (this.shellLaunchConfig.cwd) {
-            const cwdUri = typeof this._shellLaunchConfig.cwd === 'string' ? ( URI.from({
-                scheme: Schemas.file,
-                path: this._shellLaunchConfig.cwd
-            })) : this._shellLaunchConfig.cwd;
-            if (cwdUri) {
-                this._workspaceFolder = this._workspaceContextService.getWorkspaceFolder(cwdUri) ?? undefined;
-            }
-        }
-        if (!this._workspaceFolder) {
-            const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot();
-            this._workspaceFolder = activeWorkspaceRootUri ? this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
-        }
-        const scopedContextKeyService = this._register(_contextKeyService.createScoped(this._wrapperElement));
-        this._scopedInstantiationService = instantiationService.createChild(( new ServiceCollection([IContextKeyService, scopedContextKeyService])));
-        this._terminalFocusContextKey = TerminalContextKeys.focus.bindTo(scopedContextKeyService);
-        this._terminalHasFixedWidth = TerminalContextKeys.terminalHasFixedWidth.bindTo(scopedContextKeyService);
-        this._terminalHasTextContextKey = TerminalContextKeys.textSelected.bindTo(scopedContextKeyService);
-        this._terminalAltBufferActiveContextKey = TerminalContextKeys.altBufferActive.bindTo(scopedContextKeyService);
-        this._terminalShellIntegrationEnabledContextKey = TerminalContextKeys.terminalShellIntegrationEnabled.bindTo(scopedContextKeyService);
-        this._logService.trace(`terminalInstance#ctor (instanceId: ${this.instanceId})`, this._shellLaunchConfig);
-        this._register(this.capabilities.onDidAddCapabilityType(e => {
-            this._logService.debug('terminalInstance added capability', e);
-            if (e === 0 ) {
-                this.capabilities.get(0 )?.onDidChangeCwd(e => {
-                    this._cwd = e;
-                    this._setTitle(this.title, TitleEventSource.Config);
-                    this._scopedInstantiationService.invokeFunction(getDirectoryHistory)?.add(e, { remoteAuthority: this.remoteAuthority });
-                });
-            }
-            else if (e === 2 ) {
-                const commandCapability = this.capabilities.get(2 );
-                commandCapability?.onCommandFinished(e => {
-                    if (e.command.trim().length > 0) {
-                        this._scopedInstantiationService.invokeFunction(getCommandHistory)?.add(e.command, { shellType: this._shellType });
-                    }
-                });
-            }
-        }));
-        this._register(this.capabilities.onDidRemoveCapabilityType(e => this._logService.debug('terminalInstance removed capability', e)));
-        if (!this.shellLaunchConfig.executable && !workbenchEnvironmentService.remoteAuthority) {
-            this._terminalProfileResolverService.resolveIcon(this._shellLaunchConfig, OS);
-        }
-        this._icon = _shellLaunchConfig.attachPersistentProcess?.icon || _shellLaunchConfig.icon;
-        if (this.shellLaunchConfig.customPtyImplementation) {
-            this._setTitle(this._shellLaunchConfig.name, TitleEventSource.Api);
-        }
-        this.statusList = this._scopedInstantiationService.createInstance(TerminalStatusList);
-        this._initDimensions();
-        this._processManager = this._createProcessManager();
-        this._containerReadyBarrier = ( new AutoOpenBarrier(100 ));
-        this._attachBarrier = ( new AutoOpenBarrier(1000));
-        this._xtermReadyPromise = this._createXterm();
-        this._xtermReadyPromise.then(async () => {
-            await this._containerReadyBarrier.wait();
-            if (!this.shellLaunchConfig.customPtyImplementation && this._configHelper.config.shellIntegration?.enabled && !this.shellLaunchConfig.executable) {
-                const os = await this._processManager.getBackendOS();
-                const defaultProfile = (await this._terminalProfileResolverService.getDefaultProfile({ remoteAuthority: this.remoteAuthority, os }));
-                this.shellLaunchConfig.executable = defaultProfile.path;
-                this.shellLaunchConfig.args = defaultProfile.args;
-                if (this.shellLaunchConfig.isExtensionOwnedTerminal) {
-                    this.shellLaunchConfig.icon ??= defaultProfile.icon;
-                    this.shellLaunchConfig.color ??= defaultProfile.color;
-                }
-                else {
-                    this.shellLaunchConfig.icon = defaultProfile.icon;
-                    this.shellLaunchConfig.color = defaultProfile.color;
-                }
-            }
-            await this._createProcess();
-            if (this.shellLaunchConfig.attachPersistentProcess) {
-                this._cwd = this.shellLaunchConfig.attachPersistentProcess.cwd;
-                this._setTitle(this.shellLaunchConfig.attachPersistentProcess.title, this.shellLaunchConfig.attachPersistentProcess.titleSource);
-                this.setShellType(this.shellType);
-            }
-            if (this._fixedCols) {
-                await this._addScrollbar();
-            }
-        }).catch((err) => {
-            if (!this._isDisposed) {
-                throw err;
-            }
-        });
-        this._register(this._configurationService.onDidChangeConfiguration(async (e) => {
-            if (e.affectsConfiguration("accessibility.verbosity.terminal" )) {
-                this._setAriaLabel(this.xterm?.raw, this._instanceId, this.title);
-            }
-            if (e.affectsConfiguration('terminal.integrated')) {
-                this.updateConfig();
-                this.setVisible(this._isVisible);
-            }
-            const layoutSettings = [
-                "terminal.integrated.fontSize" ,
-                "terminal.integrated.fontFamily" ,
-                "terminal.integrated.fontWeight" ,
-                "terminal.integrated.fontWeightBold" ,
-                "terminal.integrated.letterSpacing" ,
-                "terminal.integrated.lineHeight" ,
-                'editor.fontFamily'
-            ];
-            if (( layoutSettings.some(id => e.affectsConfiguration(id)))) {
-                this._layoutSettingsChanged = true;
-                await this._resize();
-            }
-            if (e.affectsConfiguration("terminal.integrated.unicodeVersion" )) {
-                this._updateUnicodeVersion();
-            }
-            if (e.affectsConfiguration('editor.accessibilitySupport')) {
-                this.updateAccessibilitySupport();
-            }
-            if (e.affectsConfiguration("terminal.integrated.tabs.title" ) ||
-                e.affectsConfiguration("terminal.integrated.tabs.separator" ) ||
-                e.affectsConfiguration("terminal.integrated.tabs.description" )) {
-                this._labelComputer?.refreshLabel(this);
-            }
-        }));
-        this._register(this._workspaceContextService.onDidChangeWorkspaceFolders(() => this._labelComputer?.refreshLabel(this)));
-        this._register(this.onDidBlur(() => this.xterm?.suggestController?.hideSuggestWidget()));
-        let initialDataEventsTimeout = window.setTimeout(() => {
-            initialDataEventsTimeout = undefined;
-            this._initialDataEvents = undefined;
-        }, 10000);
-        this._register(toDisposable(() => {
-            if (initialDataEventsTimeout) {
-                window.clearTimeout(initialDataEventsTimeout);
-            }
-        }));
-        const contributionDescs = TerminalExtensionsRegistry.getTerminalContributions();
-        for (const desc of contributionDescs) {
-            if (( this._contributions.has(desc.id))) {
-                onUnexpectedError(( new Error(`Cannot have two terminal contributions with the same id ${desc.id}`)));
-                continue;
-            }
-            let contribution;
-            try {
-                contribution = this._scopedInstantiationService.createInstance(desc.ctor, this, this._processManager, this._widgetManager);
-                this._contributions.set(desc.id, contribution);
-            }
-            catch (err) {
-                onUnexpectedError(err);
-            }
-            this._xtermReadyPromise.then(xterm => {
-                contribution.xtermReady?.(xterm);
-            });
-            this.onDisposed(() => {
-                contribution.dispose();
-                this._contributions.delete(desc.id);
-                if ('instance' in contribution) {
-                    delete contribution.instance;
-                }
-                if ('_instance' in contribution) {
-                    delete contribution._instance;
-                }
-            });
-        }
-    }
-    getContribution(id) {
-        return this._contributions.get(id);
-    }
-    _getIcon() {
-        if (!this._icon) {
-            this._icon = this._processManager.processState >= 2
-                ? getIconRegistry().getIcon(this._configurationService.getValue("terminal.integrated.tabs.defaultIcon" ))
-                : undefined;
-        }
-        return this._icon;
-    }
-    _getColor() {
-        if (this.shellLaunchConfig.color) {
-            return this.shellLaunchConfig.color;
-        }
-        if (this.shellLaunchConfig?.attachPersistentProcess?.color) {
-            return this.shellLaunchConfig.attachPersistentProcess.color;
-        }
-        if (this._processManager.processState >= 2 ) {
-            return undefined;
-        }
-        return undefined;
-    }
-    _initDimensions() {
-        if (!this._container) {
-            this._cols = 80 ;
-            this._rows = 30 ;
-            return;
-        }
-        const computedStyle = window.getComputedStyle(this._container);
-        const width = parseInt(computedStyle.width);
-        const height = parseInt(computedStyle.height);
-        this._evaluateColsAndRows(width, height);
-    }
-    _evaluateColsAndRows(width, height) {
-        if (!width || !height) {
-            this._setLastKnownColsAndRows();
-            return null;
-        }
-        const dimension = this._getDimension(width, height);
-        if (!dimension) {
-            this._setLastKnownColsAndRows();
-            return null;
-        }
-        const font = this.xterm ? this.xterm.getFont() : this._configHelper.getFont();
-        const newRC = getXtermScaledDimensions(font, dimension.width, dimension.height);
-        if (!newRC) {
-            this._setLastKnownColsAndRows();
-            return null;
-        }
-        if (this._cols !== newRC.cols || this._rows !== newRC.rows) {
-            this._cols = newRC.cols;
-            this._rows = newRC.rows;
-            this._fireMaximumDimensionsChanged();
-        }
-        return dimension.width;
-    }
-    _setLastKnownColsAndRows() {
-        if (TerminalInstance_1._lastKnownGridDimensions) {
-            this._cols = TerminalInstance_1._lastKnownGridDimensions.cols;
-            this._rows = TerminalInstance_1._lastKnownGridDimensions.rows;
-        }
-    }
-    _fireMaximumDimensionsChanged() {
-        this._onMaximumDimensionsChanged.fire();
-    }
-    _getDimension(width, height) {
-        const font = this.xterm ? this.xterm.getFont() : this._configHelper.getFont();
-        if (!font || !font.charWidth || !font.charHeight) {
-            return undefined;
-        }
-        if (!this.xterm?.raw.element) {
-            return undefined;
-        }
-        const computedStyle = window.getComputedStyle(this.xterm.raw.element);
-        const horizontalPadding = parseInt(computedStyle.paddingLeft) + parseInt(computedStyle.paddingRight);
-        const verticalPadding = parseInt(computedStyle.paddingTop) + parseInt(computedStyle.paddingBottom);
-        TerminalInstance_1._lastKnownCanvasDimensions = new dom.Dimension(Math.min(8000 , width - horizontalPadding), height + (this._hasScrollBar && !this._horizontalScrollbar ? -5  : 0) - 2  - verticalPadding);
-        return TerminalInstance_1._lastKnownCanvasDimensions;
-    }
-    get persistentProcessId() { return this._processManager.persistentProcessId; }
-    get shouldPersist() { return this._processManager.shouldPersist && !this.shellLaunchConfig.isTransient && (!this.reconnectionProperties || this._configurationService.getValue('task.reconnection') === true); }
-    static getXtermConstructor(keybindingService, contextKeyService) {
-        const keybinding = keybindingService.lookupKeybinding("workbench.action.terminal.focusAccessibleBuffer" , contextKeyService);
-        if (xtermConstructor) {
-            return xtermConstructor;
-        }
-        xtermConstructor = Promises.withAsyncBody(async (resolve) => {
-            Terminal.strings.promptLabel = ( nls.localize('terminal.integrated.a11yPromptLabel', 'Terminal input'));
-            Terminal.strings.tooMuchOutput = keybinding ? ( nls.localize(
-                'terminal.integrated.useAccessibleBuffer',
-                'Use the accessible buffer {0} to manually review output',
-                keybinding.getLabel()
-            )) : ( nls.localize(
-                'terminal.integrated.useAccessibleBufferNoKb',
-                'Use the Terminal: Focus Accessible Buffer command to manually review output'
-            ));
-            resolve(Terminal);
-        });
-        return xtermConstructor;
-    }
-    async _createXterm() {
-        const Terminal = await TerminalInstance_1.getXtermConstructor(this._keybindingService, this._contextKeyService);
-        if (this._isDisposed) {
-            throw new ErrorNoTelemetry('Terminal disposed of during xterm.js creation');
-        }
-        const disableShellIntegrationReporting = (this.shellLaunchConfig.hideFromUser || this.shellLaunchConfig.executable === undefined || this.shellType === undefined) || !shellIntegrationSupportedShellTypes.includes(this.shellType);
-        const xterm = this._scopedInstantiationService.createInstance(XtermTerminal, Terminal, this._configHelper, this._cols, this._rows, {
-            getBackgroundColor: (theme) => {
-                const terminalBackground = theme.getColor(TERMINAL_BACKGROUND_COLOR);
-                if (terminalBackground) {
-                    return terminalBackground;
-                }
-                if (this.target === TerminalLocation.Editor) {
-                    return theme.getColor(editorBackground);
-                }
-                const location = this._viewDescriptorService.getViewLocationById(TERMINAL_VIEW_ID);
-                if (location === 1 ) {
-                    return theme.getColor(PANEL_BACKGROUND);
-                }
-                return theme.getColor(SIDE_BAR_BACKGROUND);
-            }
-        }, this.capabilities, this._processManager.shellIntegrationNonce, this._terminalSuggestWidgetVisibleContextKey, disableShellIntegrationReporting);
-        this.xterm = xterm;
-        this.updateAccessibilitySupport();
-        this.xterm.onDidRequestRunCommand(e => {
-            if (e.copyAsHtml) {
-                this.copySelection(true, e.command);
-            }
-            else {
-                this.sendText(e.command.command, e.noNewLine ? false : true);
-            }
-        });
-        this.xterm.onDidRequestFocus(() => this.focus());
-        this.xterm.onDidRequestSendText(e => this.sendText(e, false));
-        const initialTextWrittenPromise = this._shellLaunchConfig.initialText ? ( new Promise(r => this._writeInitialText(xterm, r))) : undefined;
-        const lineDataEventAddon = this._register(( new LineDataEventAddon(initialTextWrittenPromise)));
-        lineDataEventAddon.onLineData(e => this._onLineData.fire(e));
-        this._lineDataEventAddon = lineDataEventAddon;
-        setTimeout(() => {
-            this._register(xterm.raw.onBell(() => {
-                if (this._configHelper.config.enableBell) {
-                    this.statusList.add({
-                        id: "bell" ,
-                        severity: Severity.Warning,
-                        icon: Codicon.bell,
-                        tooltip: ( nls.localize('bellStatus', "Bell"))
-                    }, this._configHelper.config.bellDuration);
-                    this._audioCueService.playSound(AudioCue.terminalBell.sound.getSound());
-                }
-            }));
-        }, 1000);
-        this._register(xterm.raw.onSelectionChange(async () => this._onSelectionChange()));
-        this._register(xterm.raw.buffer.onBufferChange(() => this._refreshAltBufferContextKey()));
-        this._processManager.onProcessData(e => this._onProcessData(e));
-        this._register(xterm.raw.onData(async (data) => {
-            await this._processManager.write(data);
-            this._onDidInputData.fire(this);
-        }));
-        this._register(xterm.raw.onBinary(data => this._processManager.processBinary(data)));
-        this._processManager.onProcessReady(async (processTraits) => {
-            if (this._processManager.os) {
-                lineDataEventAddon.setOperatingSystem(this._processManager.os);
-            }
-            xterm.raw.options.windowsPty = processTraits.windowsPty;
-        });
-        this._processManager.onRestoreCommands(e => this.xterm?.shellIntegration.deserialize(e));
-        this._register(this._viewDescriptorService.onDidChangeLocation(({ views }) => {
-            if (( views.some(v => v.id === TERMINAL_VIEW_ID))) {
-                xterm.refresh();
-            }
-        }));
-        if (!( this.capabilities.has(0 ))) {
-            let onKeyListener = xterm.raw.onKey(e => {
-                const event = ( new StandardKeyboardEvent(e.domEvent));
-                if (event.equals(3 )) {
-                    this._updateProcessCwd();
-                }
-            });
-            this._register(this.capabilities.onDidAddCapabilityType(e => {
-                if (e === 0 ) {
-                    onKeyListener?.dispose();
-                    onKeyListener = undefined;
-                }
-            }));
-        }
-        this._pathService.userHome().then(userHome => {
-            this._userHome = userHome.fsPath;
-        });
-        if (this._isVisible) {
-            this._open();
-        }
-        return xterm;
-    }
-    async _onLineDataSetup() {
-        const xterm = this.xterm || (await this._xtermReadyPromise);
-        xterm.raw.loadAddon(this._lineDataEventAddon);
-    }
-    async runCommand(commandLine, addNewLine) {
-        if (this.capabilities.get(2 )?.hasInput !== false) {
-            await this.sendText('\x03', false);
-            await timeout(100);
-        }
-        await this.sendText(commandLine, addNewLine, !addNewLine);
-    }
-    async runRecent(type, filterMode, value) {
-        return this._scopedInstantiationService.invokeFunction(showRunRecentQuickPick, this, this._terminalInRunCommandPicker, type, filterMode, value);
-    }
-    detachFromElement() {
-        this._wrapperElement.remove();
-        this._container = undefined;
-    }
-    attachToElement(container) {
-        if (this._container === container) {
-            return;
-        }
-        this._attachBarrier.open();
-        this._container = container;
-        this._container.appendChild(this._wrapperElement);
-        this.xterm?.refresh();
-        setTimeout(() => this._initDragAndDrop(container));
-    }
-    _open() {
-        if (!this.xterm || this.xterm.raw.element) {
-            return;
-        }
-        if (!this._container || !this._container.isConnected) {
-            throw new Error('A container element needs to be set with `attachToElement` and be part of the DOM before calling `_open`');
-        }
-        const xtermElement = document.createElement('div');
-        this._wrapperElement.appendChild(xtermElement);
-        this._container.appendChild(this._wrapperElement);
-        const xterm = this.xterm;
-        this._wrapperElement.xterm = xterm.raw;
-        const screenElement = xterm.attachToElement(xtermElement);
-        this._register(xterm.shellIntegration.onDidChangeStatus(() => {
-            if (this.hasFocus) {
-                this._setShellIntegrationContextKey();
-            }
-            else {
-                this._terminalShellIntegrationEnabledContextKey.reset();
-            }
-        }));
-        if (!xterm.raw.element || !xterm.raw.textarea) {
-            throw new Error('xterm elements not set after open');
-        }
-        this._setAriaLabel(xterm.raw, this._instanceId, this._title);
-        xterm.raw.attachCustomKeyEventHandler((event) => {
-            if (this._isExiting) {
-                return false;
-            }
-            const standardKeyboardEvent = ( new StandardKeyboardEvent(event));
-            const resolveResult = this._keybindingService.softDispatch(standardKeyboardEvent, standardKeyboardEvent.target);
-            const isValidChord = resolveResult.kind === 1  && this._configHelper.config.allowChords && event.key !== 'Escape';
-            if (this._keybindingService.inChordMode || isValidChord) {
-                event.preventDefault();
-                return false;
-            }
-            const SHOW_TERMINAL_CONFIG_PROMPT_KEY = 'terminal.integrated.showTerminalConfigPrompt';
-            const EXCLUDED_KEYS = ['RightArrow', 'LeftArrow', 'UpArrow', 'DownArrow', 'Space', 'Meta', 'Control', 'Shift', 'Alt', '', 'Delete', 'Backspace', 'Tab'];
-            if (this._storageService.getBoolean(SHOW_TERMINAL_CONFIG_PROMPT_KEY, -1 , true) &&
-                !EXCLUDED_KEYS.includes(event.key) &&
-                !event.ctrlKey &&
-                !event.shiftKey &&
-                !event.altKey) {
-                this._hasHadInput = true;
-            }
-            if (resolveResult.kind === 2  && resolveResult.commandId && ( this._skipTerminalCommands.some(k => k === resolveResult.commandId)) && !this._configHelper.config.sendKeybindingsToShell) {
-                if (this._storageService.getBoolean(SHOW_TERMINAL_CONFIG_PROMPT_KEY, -1 , true) &&
-                    this._hasHadInput &&
-                    !TERMINAL_CREATION_COMMANDS.includes(resolveResult.commandId)) {
-                    this._notificationService.prompt(Severity.Info, ( nls.localize(
-                        'keybindingHandling',
-                        "Some keybindings don't go to the terminal by default and are handled by {0} instead.",
-                        this._productService.nameLong
-                    )), [
-                        {
-                            label: ( nls.localize('configureTerminalSettings', "Configure Terminal Settings")),
-                            run: () => {
-                                this._preferencesService.openSettings({ jsonEditor: false, query: `@id:${"terminal.integrated.commandsToSkipShell" },${"terminal.integrated.sendKeybindingsToShell" },${"terminal.integrated.allowChords" }` });
-                            }
-                        }
-                    ]);
-                    this._storageService.store(SHOW_TERMINAL_CONFIG_PROMPT_KEY, false, -1 , 0 );
-                }
-                event.preventDefault();
-                return false;
-            }
-            if (this._configHelper.config.allowMnemonics && !isMacintosh && event.altKey) {
-                return false;
-            }
-            if (TabFocus.getTabFocusMode("terminalFocus" ) && event.key === 'Tab') {
-                return false;
-            }
-            if (event.key === 'Tab' && event.shiftKey) {
-                event.preventDefault();
-                return true;
-            }
-            if (isWindows && event.altKey && event.key === 'F4' && !event.ctrlKey) {
-                return false;
-            }
-            if (!BrowserFeatures.clipboard.readText && event.key === 'v' && event.ctrlKey) {
-                return false;
-            }
-            return true;
-        });
-        this._register(dom.addDisposableListener(xterm.raw.element, 'mousedown', () => {
-            const listener = dom.addDisposableListener(document, 'mouseup', () => {
-                setTimeout(() => this._refreshSelectionContextKey(), 0);
-                listener.dispose();
-            });
-        }));
-        this._register(dom.addDisposableListener(xterm.raw.element, 'touchstart', () => {
-            xterm.raw.focus();
-        }));
-        this._register(dom.addDisposableListener(xterm.raw.element, 'keyup', () => {
-            setTimeout(() => this._refreshSelectionContextKey(), 0);
-        }));
-        this._register(dom.addDisposableListener(xterm.raw.textarea, 'focus', () => this._setFocus(true)));
-        this._register(dom.addDisposableListener(xterm.raw.textarea, 'blur', () => this._setFocus(false)));
-        this._register(dom.addDisposableListener(xterm.raw.textarea, 'focusout', () => this._setFocus(false)));
-        this._initDragAndDrop(this._container);
-        this._widgetManager.attachToElement(screenElement);
-        if (this._lastLayoutDimensions) {
-            this.layout(this._lastLayoutDimensions);
-        }
-        this.updateConfig();
-        if (xterm.raw.options.disableStdin) {
-            this._attachPressAnyKeyToCloseListener(xterm.raw);
-        }
-    }
-    _setFocus(focused) {
-        if (focused) {
-            this._terminalFocusContextKey.set(true);
-            this._setShellIntegrationContextKey();
-            this._onDidFocus.fire(this);
-        }
-        else {
-            this.resetFocusContextKey();
-            this._onDidBlur.fire(this);
-            this._refreshSelectionContextKey();
-        }
-    }
-    _setShellIntegrationContextKey() {
-        if (this.xterm) {
-            this._terminalShellIntegrationEnabledContextKey.set(this.xterm.shellIntegration.status === 2 );
-        }
-    }
-    resetFocusContextKey() {
-        this._terminalFocusContextKey.reset();
-        this._terminalShellIntegrationEnabledContextKey.reset();
-    }
-    _initDragAndDrop(container) {
-        const dndController = this._register(this._scopedInstantiationService.createInstance(TerminalInstanceDragAndDropController, container));
-        dndController.onDropTerminal(e => this._onRequestAddInstanceToGroup.fire(e));
-        dndController.onDropFile(async (path) => {
-            this.focus();
-            await this.sendPath(path, false);
-        });
-        this._dndObserver.value = new dom.DragAndDropObserver(container, dndController);
-    }
-    hasSelection() {
-        return this.xterm ? this.xterm.raw.hasSelection() : false;
-    }
-    async copySelection(asHtml, command) {
-        const xterm = await this._xtermReadyPromise;
-        await xterm.copySelection(asHtml, command);
-    }
-    get selection() {
-        return this.xterm && this.hasSelection() ? this.xterm.raw.getSelection() : undefined;
-    }
-    clearSelection() {
-        this.xterm?.raw.clearSelection();
-    }
-    _refreshAltBufferContextKey() {
-        this._terminalAltBufferActiveContextKey.set(!!(this.xterm && this.xterm.raw.buffer.active === this.xterm.raw.buffer.alternate));
-    }
-    async _shouldPasteText(text) {
-        if (this.xterm?.raw.modes.bracketedPasteMode) {
-            return true;
-        }
-        const textForLines = text.split(/\r?\n/);
-        if (textForLines.length === 2 && textForLines[1].trim().length === 0) {
-            return true;
-        }
-        if (textForLines.length === 1 || !this._configurationService.getValue("terminal.integrated.enableMultiLinePasteWarning" )) {
-            return true;
-        }
-        const displayItemsCount = 3;
-        const maxPreviewLineLength = 30;
-        let detail = ( nls.localize('preview', "Preview:"));
-        for (let i = 0; i < Math.min(textForLines.length, displayItemsCount); i++) {
-            const line = textForLines[i];
-            const cleanedLine = line.length > maxPreviewLineLength ? `${line.slice(0, maxPreviewLineLength)}…` : line;
-            detail += `\n${cleanedLine}`;
-        }
-        if (textForLines.length > displayItemsCount) {
-            detail += `\n…`;
-        }
-        const { confirmed, checkboxChecked } = await this._dialogService.confirm({
-            message: ( nls.localize(
-                'confirmMoveTrashMessageFilesAndDirectories',
-                "Are you sure you want to paste {0} lines of text into the terminal?",
-                textForLines.length
-            )),
-            detail,
-            primaryButton: ( nls.localize(
-                { key: 'multiLinePasteButton', comment: ['&& denotes a mnemonic'] },
-                "&&Paste"
-            )),
-            checkbox: {
-                label: ( nls.localize('doNotAskAgain', "Do not ask me again"))
-            }
-        });
-        if (confirmed && checkboxChecked) {
-            await this._configurationService.updateValue("terminal.integrated.enableMultiLinePasteWarning" , false);
-        }
-        return confirmed;
-    }
-    dispose(reason) {
-        if (this._isDisposed) {
-            return;
-        }
-        this._isDisposed = true;
-        this._logService.trace(`terminalInstance#dispose (instanceId: ${this.instanceId})`);
-        dispose(this._widgetManager);
-        if (this.xterm?.raw.element) {
-            this._hadFocusOnExit = this.hasFocus;
-        }
-        if (this._wrapperElement.xterm) {
-            this._wrapperElement.xterm = undefined;
-        }
-        if (this._horizontalScrollbar) {
-            this._horizontalScrollbar.dispose();
-            this._horizontalScrollbar = undefined;
-        }
-        try {
-            this.xterm?.dispose();
-        }
-        catch (err) {
-            this._logService.error('Exception occurred during xterm disposal', err);
-        }
-        if (isFirefox) {
-            this.resetFocusContextKey();
-            this._terminalHasTextContextKey.reset();
-            this._onDidBlur.fire(this);
-        }
-        if (this._pressAnyKeyToCloseListener) {
-            this._pressAnyKeyToCloseListener.dispose();
-            this._pressAnyKeyToCloseListener = undefined;
-        }
-        if (this._exitReason === undefined) {
-            this._exitReason = reason ?? TerminalExitReason.Unknown;
-        }
-        this._processManager.dispose();
-        this._onProcessExit(undefined);
-        this._onDisposed.fire(this);
-        super.dispose();
-    }
-    async detachProcessAndDispose(reason) {
-        await this._processManager.detachFromProcess(reason === TerminalExitReason.User);
-        this.dispose(reason);
-    }
-    focus(force) {
-        this._refreshAltBufferContextKey();
-        if (!this.xterm) {
-            return;
-        }
-        if (force || !window.getSelection()?.toString()) {
-            this.xterm.raw.focus();
-            this._onDidRequestFocus.fire();
-        }
-    }
-    async focusWhenReady(force) {
-        await this._xtermReadyPromise;
-        await this._attachBarrier.wait();
-        this.focus(force);
-    }
-    async paste() {
-        if (!this.xterm) {
-            return;
-        }
-        const currentText = await this._clipboardService.readText();
-        if (!(await this._shouldPasteText(currentText))) {
-            return;
-        }
-        this.focus();
-        this.xterm.raw.paste(currentText);
-    }
-    async pasteSelection() {
-        if (!this.xterm) {
-            return;
-        }
-        const currentText = await this._clipboardService.readText('selection');
-        if (!(await this._shouldPasteText(currentText))) {
-            return;
-        }
-        this.focus();
-        this.xterm.raw.paste(currentText);
-    }
-    async sendText(text, addNewLine, bracketedPasteMode) {
-        if (bracketedPasteMode && this.xterm?.raw.modes.bracketedPasteMode) {
-            text = `\x1b[200~${text}\x1b[201~`;
-        }
-        text = text.replace(/\r?\n/g, '\r');
-        if (addNewLine && !text.endsWith('\r')) {
-            text += '\r';
-        }
-        await this._processManager.write(text);
-        this._onDidInputData.fire(this);
-        this.xterm?.suggestController?.handleNonXtermData(text);
-        this.xterm?.scrollToBottom();
-        this._onDidRunText.fire();
-    }
-    async sendPath(originalPath, addNewLine) {
-        return this.sendText(await this.preparePathForShell(originalPath), addNewLine);
-    }
-    async preparePathForShell(originalPath) {
-        await this.processReady;
-        return preparePathForShell(originalPath, this.shellLaunchConfig.executable, this.title, this.shellType, this._processManager.backend, this._processManager.os);
-    }
-    setVisible(visible) {
-        this._isVisible = visible;
-        this._wrapperElement.classList.toggle('active', visible);
-        if (visible && this.xterm) {
-            this._open();
-            this._resize();
-            setTimeout(() => this.xterm.forceRefresh(), 0);
-        }
-    }
-    scrollDownLine() {
-        this.xterm?.scrollDownLine();
-    }
-    scrollDownPage() {
-        this.xterm?.scrollDownPage();
-    }
-    scrollToBottom() {
-        this.xterm?.scrollToBottom();
-    }
-    scrollUpLine() {
-        this.xterm?.scrollUpLine();
-    }
-    scrollUpPage() {
-        this.xterm?.scrollUpPage();
-    }
-    scrollToTop() {
-        this.xterm?.scrollToTop();
-    }
-    clearBuffer() {
-        this._processManager.clearBuffer();
-        this.xterm?.clearBuffer();
-    }
-    _refreshSelectionContextKey() {
-        const isActive = !!this._viewsService.getActiveViewWithId(TERMINAL_VIEW_ID);
-        let isEditorActive = false;
-        const editor = this._editorService.activeEditor;
-        if (editor) {
-            isEditorActive = editor instanceof TerminalEditorInput;
-        }
-        this._terminalHasTextContextKey.set((isActive || isEditorActive) && this.hasSelection());
-    }
-    _createProcessManager() {
-        let deserializedCollections;
-        if (this.shellLaunchConfig.attachPersistentProcess?.environmentVariableCollections) {
-            deserializedCollections = deserializeEnvironmentVariableCollections(this.shellLaunchConfig.attachPersistentProcess.environmentVariableCollections);
-        }
-        const processManager = this._scopedInstantiationService.createInstance(TerminalProcessManager, this._instanceId, this._configHelper, this.shellLaunchConfig?.cwd, deserializedCollections, this.shellLaunchConfig.attachPersistentProcess?.shellIntegrationNonce);
-        this.capabilities.add(processManager.capabilities);
-        processManager.onProcessReady(async (e) => {
-            this._onProcessIdReady.fire(this);
-            this._initialCwd = await this.getInitialCwd();
-            if (!this._labelComputer) {
-                this._labelComputer = this._register(this._scopedInstantiationService.createInstance(TerminalLabelComputer, this._configHelper));
-                this._register(this._labelComputer.onDidChangeLabel(e => {
-                    this._title = e.title;
-                    this._description = e.description;
-                    this._onTitleChanged.fire(this);
-                }));
-            }
-            if (this._shellLaunchConfig.name) {
-                this._setTitle(this._shellLaunchConfig.name, TitleEventSource.Api);
-            }
-            else {
-                setTimeout(() => {
-                    this._xtermReadyPromise.then(xterm => {
-                        this._messageTitleDisposable.value = xterm.raw.onTitleChange(e => this._onTitleChange(e));
-                    });
-                });
-                this._setTitle(this._shellLaunchConfig.executable, TitleEventSource.Process);
-            }
-        });
-        processManager.onProcessExit(exitCode => this._onProcessExit(exitCode));
-        processManager.onDidChangeProperty(({ type, value }) => {
-            switch (type) {
-                case "cwd" :
-                    this._cwd = value;
-                    this._labelComputer?.refreshLabel(this);
-                    break;
-                case "initialCwd" :
-                    this._initialCwd = value;
-                    this._cwd = this._initialCwd;
-                    this._setTitle(this.title, TitleEventSource.Config);
-                    this._icon = this._shellLaunchConfig.attachPersistentProcess?.icon || this._shellLaunchConfig.icon;
-                    this._onIconChanged.fire({ instance: this, userInitiated: false });
-                    break;
-                case "title" :
-                    this._setTitle(value ?? '', TitleEventSource.Process);
-                    break;
-                case "overrideDimensions" :
-                    this.setOverrideDimensions(value, true);
-                    break;
-                case "resolvedShellLaunchConfig" :
-                    this._setResolvedShellLaunchConfig(value);
-                    break;
-                case "shellType" :
-                    this.setShellType(value);
-                    break;
-                case "hasChildProcesses" :
-                    this._onDidChangeHasChildProcesses.fire(value);
-                    break;
-                case "usedShellIntegrationInjection" :
-                    this._usedShellIntegrationInjection = true;
-                    break;
-            }
-        });
-        processManager.onProcessData(ev => {
-            this._initialDataEvents?.push(ev.data);
-            this._onData.fire(ev.data);
-        });
-        processManager.onProcessReplayComplete(() => this._onProcessReplayComplete.fire());
-        processManager.onEnvironmentVariableInfoChanged(e => this._onEnvironmentVariableInfoChanged(e));
-        processManager.onPtyDisconnect(() => {
-            if (this.xterm) {
-                this.xterm.raw.options.disableStdin = true;
-            }
-            this.statusList.add({
-                id: "disconnected" ,
-                severity: Severity.Error,
-                icon: Codicon.debugDisconnect,
-                tooltip: ( nls.localize('disconnectStatus', "Lost connection to process"))
-            });
-        });
-        processManager.onPtyReconnect(() => {
-            if (this.xterm) {
-                this.xterm.raw.options.disableStdin = false;
-            }
-            this.statusList.remove("disconnected" );
-        });
-        return processManager;
-    }
-    async _createProcess() {
-        if (this._isDisposed) {
-            return;
-        }
-        const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot(Schemas.file);
-        if (activeWorkspaceRootUri) {
-            const trusted = await this._trust();
-            if (!trusted) {
-                this._onProcessExit({ message: ( nls.localize(
-                    'workspaceNotTrustedCreateTerminal',
-                    "Cannot launch a terminal process in an untrusted workspace"
-                )) });
-            }
-        }
-        else if (this._cwd && this._userHome && this._cwd !== this._userHome) {
-            this._onProcessExit({
-                message: ( nls.localize(
-                    'workspaceNotTrustedCreateTerminalCwd',
-                    "Cannot launch a terminal process in an untrusted workspace with cwd {0} and userHome {1}",
-                    this._cwd,
-                    this._userHome
-                ))
-            });
-        }
-        if (this._container && this._cols === 0 && this._rows === 0) {
-            this._initDimensions();
-            this.xterm?.raw.resize(this._cols || 80 , this._rows || 30 );
-        }
-        const originalIcon = this.shellLaunchConfig.icon;
-        await this._processManager.createProcess(this._shellLaunchConfig, this._cols || 80 , this._rows || 30 ).then(result => {
-            if (result) {
-                if ('message' in result) {
-                    this._onProcessExit(result);
-                }
-                else if ('injectedArgs' in result) {
-                    this._injectedArgs = result.injectedArgs;
-                }
-            }
-        });
-        if (this.xterm?.shellIntegration) {
-            this.capabilities.add(this.xterm.shellIntegration.capabilities);
-        }
-        if (originalIcon !== this.shellLaunchConfig.icon || this.shellLaunchConfig.color) {
-            this._icon = this._shellLaunchConfig.attachPersistentProcess?.icon || this._shellLaunchConfig.icon;
-            this._onIconChanged.fire({ instance: this, userInitiated: false });
-        }
-    }
-    registerMarker() {
-        return this.xterm?.raw.registerMarker();
-    }
-    addBufferMarker(properties) {
-        this.capabilities.get(4 )?.addMark(properties);
-    }
-    scrollToMark(startMarkId, endMarkId, highlight) {
-        this.xterm?.markTracker.scrollToClosestMarker(startMarkId, endMarkId, highlight);
-    }
-    async freePortKillProcess(port, command) {
-        await this._processManager?.freePortKillProcess(port);
-        this.runCommand(command, false);
-    }
-    _onProcessData(ev) {
-        const messageId = ++this._latestXtermWriteData;
-        if (ev.trackCommit) {
-            ev.writePromise = ( new Promise(r => {
-                this.xterm?.raw.write(ev.data, () => {
-                    this._latestXtermParseData = messageId;
-                    this._processManager.acknowledgeDataEvent(ev.data.length);
-                    r();
-                });
-            }));
-        }
-        else {
-            this.xterm?.raw.write(ev.data, () => {
-                this._latestXtermParseData = messageId;
-                this._processManager.acknowledgeDataEvent(ev.data.length);
-            });
-        }
-    }
-    async _onProcessExit(exitCodeOrError) {
-        if (this._isExiting) {
-            return;
-        }
-        const parsedExitResult = parseExitResult(exitCodeOrError, this.shellLaunchConfig, this._processManager.processState, this._initialCwd);
-        if (this._usedShellIntegrationInjection && this._processManager.processState === 4  && parsedExitResult?.code !== 0) {
-            this._relaunchWithShellIntegrationDisabled(parsedExitResult?.message);
-            this._onExit.fire(exitCodeOrError);
-            return;
-        }
-        this._isExiting = true;
-        await this._flushXtermData();
-        this._exitCode = parsedExitResult?.code;
-        const exitMessage = parsedExitResult?.message;
-        this._logService.debug('Terminal process exit', 'instanceId', this.instanceId, 'code', this._exitCode, 'processState', this._processManager.processState);
-        const waitOnExit = this.waitOnExit;
-        if (waitOnExit && this._processManager.processState !== 5 ) {
-            this._xtermReadyPromise.then(xterm => {
-                if (exitMessage) {
-                    xterm.raw.write(formatMessageForTerminal(exitMessage));
-                }
-                switch (typeof waitOnExit) {
-                    case 'string':
-                        xterm.raw.write(formatMessageForTerminal(waitOnExit, { excludeLeadingNewLine: true }));
-                        break;
-                    case 'function':
-                        if (this.exitCode !== undefined) {
-                            xterm.raw.write(formatMessageForTerminal(waitOnExit(this.exitCode), { excludeLeadingNewLine: true }));
-                        }
-                        break;
-                }
-                xterm.raw.options.disableStdin = true;
-                if (xterm.raw.textarea) {
-                    this._attachPressAnyKeyToCloseListener(xterm.raw);
-                }
-            });
-        }
-        else {
-            this.dispose(TerminalExitReason.Process);
-            if (exitMessage) {
-                const failedDuringLaunch = this._processManager.processState === 4 ;
-                if (failedDuringLaunch || this._configHelper.config.showExitAlert) {
-                    this._notificationService.notify({
-                        message: exitMessage,
-                        severity: Severity.Error,
-                        actions: { primary: [this._scopedInstantiationService.createInstance(TerminalLaunchHelpAction)] }
-                    });
-                }
-                else {
-                    this._logService.warn(exitMessage);
-                }
-            }
-        }
-        this._onExit.fire(exitCodeOrError);
-        if (this._isDisposed) {
-            this._onExit.dispose();
-        }
-    }
-    _relaunchWithShellIntegrationDisabled(exitMessage) {
-        this._shellLaunchConfig.ignoreShellIntegration = true;
-        this.relaunch();
-        this.statusList.add({
-            id: "shell-integration-attention-needed" ,
-            severity: Severity.Warning,
-            icon: Codicon.warning,
-            tooltip: (`${exitMessage} ` ?? '') + ( nls.localize(
-                'launchFailed.exitCodeOnlyShellIntegration',
-                'Disabling shell integration in user settings might help.'
-            )),
-            hoverActions: [{
-                    commandId: "workbench.action.terminal.learnMore" ,
-                    label: ( nls.localize('shellIntegration.learnMore', "Learn more about shell integration")),
-                    run: () => {
-                        this._openerService.open('https://code.visualstudio.com/docs/editor/integrated-terminal#_shell-integration');
-                    }
-                }, {
-                    commandId: 'workbench.action.openSettings',
-                    label: ( nls.localize('shellIntegration.openSettings', "Open user settings")),
-                    run: () => {
-                        this._commandService.executeCommand('workbench.action.openSettings', 'terminal.integrated.shellIntegration.enabled');
-                    }
-                }]
-        });
-        this._telemetryService.publicLog2('terminal/shellIntegrationFailureProcessExit');
-    }
-    _flushXtermData() {
-        if (this._latestXtermWriteData === this._latestXtermParseData) {
-            return Promise.resolve();
-        }
-        let retries = 0;
-        return ( new Promise(r => {
-            const interval = setInterval(() => {
-                if (this._latestXtermWriteData === this._latestXtermParseData || ++retries === 5) {
-                    clearInterval(interval);
-                    r();
-                }
-            }, 20);
-        }));
-    }
-    _attachPressAnyKeyToCloseListener(xterm) {
-        if (xterm.textarea && !this._pressAnyKeyToCloseListener) {
-            this._pressAnyKeyToCloseListener = dom.addDisposableListener(xterm.textarea, 'keypress', (event) => {
-                if (this._pressAnyKeyToCloseListener) {
-                    this._pressAnyKeyToCloseListener.dispose();
-                    this._pressAnyKeyToCloseListener = undefined;
-                    this.dispose(TerminalExitReason.Process);
-                    event.preventDefault();
-                }
-            });
-        }
-    }
-    _writeInitialText(xterm, callback) {
-        if (!this._shellLaunchConfig.initialText) {
-            callback?.();
-            return;
-        }
-        const text = typeof this._shellLaunchConfig.initialText === 'string'
-            ? this._shellLaunchConfig.initialText
-            : this._shellLaunchConfig.initialText?.text;
-        if (typeof this._shellLaunchConfig.initialText === 'string') {
-            xterm.raw.writeln(text, callback);
-        }
-        else {
-            if (this._shellLaunchConfig.initialText.trailingNewLine) {
-                xterm.raw.writeln(text, callback);
-            }
-            else {
-                xterm.raw.write(text, callback);
-            }
-        }
-    }
-    async reuseTerminal(shell, reset = false) {
-        this._pressAnyKeyToCloseListener?.dispose();
-        this._pressAnyKeyToCloseListener = undefined;
-        const xterm = this.xterm;
-        if (xterm) {
-            if (!reset) {
-                await ( new Promise(r => xterm.raw.write('\n\x1b[G', r)));
-            }
-            if (shell.initialText) {
-                this._shellLaunchConfig.initialText = shell.initialText;
-                await ( new Promise(r => this._writeInitialText(xterm, r)));
-            }
-            if (this._isExiting && this._shellLaunchConfig.waitOnExit) {
-                xterm.raw.options.disableStdin = false;
-                this._isExiting = false;
-            }
-            if (reset) {
-                xterm.clearDecorations();
-            }
-        }
-        this.statusList.remove("relaunch-needed" );
-        if (!reset) {
-            shell.initialText = ' ';
-        }
-        this._shellLaunchConfig = shell;
-        await this._processManager.relaunch(this._shellLaunchConfig, this._cols || 80 , this._rows || 30 , reset).then(result => {
-            if (result) {
-                if ('message' in result) {
-                    this._onProcessExit(result);
-                }
-                else if ('injectedArgs' in result) {
-                    this._injectedArgs = result.injectedArgs;
-                }
-            }
-        });
-    }
-    relaunch() {
-        this.reuseTerminal(this._shellLaunchConfig, true);
-    }
-    _onTitleChange(title) {
-        if (this.isTitleSetByProcess) {
-            this._setTitle(title, TitleEventSource.Sequence);
-        }
-    }
-    async _trust() {
-        return (await this._workspaceTrustRequestService.requestWorkspaceTrust({
-            message: ( nls.localize(
-                'terminal.requestTrust',
-                "Creating a terminal process requires executing code"
-            ))
-        })) === true;
-    }
-    async _onSelectionChange() {
-        this._onDidChangeSelection.fire(this);
-        if (this._configurationService.getValue("terminal.integrated.copyOnSelection" )) {
-            if (this.hasSelection()) {
-                await this.copySelection();
-            }
-        }
-    }
-    async _updateProcessCwd() {
-        if (this._isDisposed || this.shellLaunchConfig.customPtyImplementation) {
-            return;
-        }
-        try {
-            const cwd = await this._refreshProperty("cwd" );
-            if (typeof cwd !== 'string') {
-                throw new Error(`cwd is not a string ${cwd}`);
-            }
-        }
-        catch (e) {
-            if (e instanceof Error && e.message === 'Cannot refresh property when process is not set') {
-                return;
-            }
-            throw e;
-        }
-    }
-    updateConfig() {
-        this._setCommandsToSkipShell(this._configHelper.config.commandsToSkipShell);
-        this._refreshEnvironmentVariableInfoWidgetState(this._processManager.environmentVariableInfo);
-    }
-    async _updateUnicodeVersion() {
-        this._processManager.setUnicodeVersion(this._configHelper.config.unicodeVersion);
-    }
-    updateAccessibilitySupport() {
-        this.xterm.raw.options.screenReaderMode = this._accessibilityService.isScreenReaderOptimized();
-    }
-    _setCommandsToSkipShell(commands) {
-        const excludeCommands = ( commands.filter(command => command[0] === '-').map(command => command.slice(1)));
-        this._skipTerminalCommands = DEFAULT_COMMANDS_TO_SKIP_SHELL.filter(defaultCommand => {
-            return !excludeCommands.includes(defaultCommand);
-        }).concat(commands);
-    }
-    layout(dimension) {
-        this._lastLayoutDimensions = dimension;
-        if (this.disableLayout) {
-            return;
-        }
-        if (dimension.width <= 0 || dimension.height <= 0) {
-            return;
-        }
-        const terminalWidth = this._evaluateColsAndRows(dimension.width, dimension.height);
-        if (!terminalWidth) {
-            return;
-        }
-        this._resize();
-        this._containerReadyBarrier.open();
-        for (const contribution of ( this._contributions.values())) {
-            if (!this.xterm) {
-                this._xtermReadyPromise.then(xterm => contribution.layout?.(xterm, dimension));
-            }
-            else {
-                contribution.layout?.(this.xterm, dimension);
-            }
-        }
-    }
-    async _resize() {
-        this._resizeNow(false);
-    }
-    async _resizeNow(immediate) {
-        let cols = this.cols;
-        let rows = this.rows;
-        if (this.xterm) {
-            if (this._isVisible && this._layoutSettingsChanged) {
-                const font = this.xterm.getFont();
-                const config = this._configHelper.config;
-                this.xterm.raw.options.letterSpacing = font.letterSpacing;
-                this.xterm.raw.options.lineHeight = font.lineHeight;
-                this.xterm.raw.options.fontSize = font.fontSize;
-                this.xterm.raw.options.fontFamily = font.fontFamily;
-                this.xterm.raw.options.fontWeight = config.fontWeight;
-                this.xterm.raw.options.fontWeightBold = config.fontWeightBold;
-                this._initDimensions();
-                cols = this.cols;
-                rows = this.rows;
-                this._layoutSettingsChanged = false;
-            }
-            if (isNaN(cols) || isNaN(rows)) {
-                return;
-            }
-            if (cols !== this.xterm.raw.cols || rows !== this.xterm.raw.rows) {
-                if (this._fixedRows || this._fixedCols) {
-                    await this._updateProperty("fixedDimensions" , { cols: this._fixedCols, rows: this._fixedRows });
-                }
-                this._onDimensionsChanged.fire();
-            }
-            this.xterm.raw.resize(cols, rows);
-            TerminalInstance_1._lastKnownGridDimensions = { cols, rows };
-            if (this._isVisible) {
-                this.xterm.forceUnpause();
-            }
-        }
-        if (immediate) {
-            this._processManager.setDimensions(cols, rows, true);
-        }
-        else {
-            await this._processManager.setDimensions(cols, rows);
-        }
-    }
-    setShellType(shellType) {
-        this._shellType = shellType;
-        if (shellType) {
-            this._terminalShellTypeContextKey.set(shellType?.toString());
-        }
-    }
-    _setAriaLabel(xterm, terminalId, title) {
-        const labelParts = [];
-        if (xterm && xterm.textarea) {
-            if (title && title.length > 0) {
-                labelParts.push(( nls.localize(
-                    'terminalTextBoxAriaLabelNumberAndTitle',
-                    "Terminal {0}, {1}",
-                    terminalId,
-                    title
-                )));
-            }
-            else {
-                labelParts.push(( nls.localize('terminalTextBoxAriaLabel', "Terminal {0}", terminalId)));
-            }
-            const screenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
-            if (!screenReaderOptimized) {
-                labelParts.push(( nls.localize(
-                    'terminalScreenReaderMode',
-                    "Run the command: Toggle Screen Reader Accessibility Mode for an optimized screen reader experience"
-                )));
-            }
-            const accessibilityHelpKeybinding = this._keybindingService.lookupKeybinding("editor.action.accessibilityHelp" )?.getLabel();
-            if (this._configurationService.getValue("accessibility.verbosity.terminal" ) && accessibilityHelpKeybinding) {
-                labelParts.push(( nls.localize(
-                    'terminalHelpAriaLabel',
-                    "Use {0} for terminal accessibility help",
-                    accessibilityHelpKeybinding
-                )));
-            }
-            xterm.textarea.setAttribute('aria-label', labelParts.join('\n'));
-        }
-    }
-    _updateTitleProperties(title, eventSource) {
-        if (!title) {
-            return this._processName;
-        }
-        switch (eventSource) {
-            case TitleEventSource.Process:
-                if (this._processManager.os === 1 ) {
-                    title = path.win32.parse(title).name;
-                }
-                else {
-                    const firstSpaceIndex = title.indexOf(' ');
-                    if (title.startsWith('/')) {
-                        title = path.basename(title);
-                    }
-                    else if (firstSpaceIndex > -1) {
-                        title = title.substring(0, firstSpaceIndex);
-                    }
-                }
-                this._processName = title;
-                break;
-            case TitleEventSource.Api:
-                this._staticTitle = title;
-                this._messageTitleDisposable.value = undefined;
-                break;
-            case TitleEventSource.Sequence:
-                this._sequence = title;
-                if (this._processManager.os === 1 ) {
-                    if (title.match(/^[a-zA-Z]:\\.+\.[a-zA-Z]{1,3}/)) {
-                        title = path.win32.parse(title).name;
-                        this._sequence = title;
-                    }
-                    else {
-                        this._sequence = undefined;
-                    }
-                }
-                break;
-        }
-        this._titleSource = eventSource;
-        return title;
-    }
-    setOverrideDimensions(dimensions, immediate = false) {
-        if (this._dimensionsOverride && this._dimensionsOverride.forceExactSize && !dimensions && this._rows === 0 && this._cols === 0) {
-            this._cols = this._dimensionsOverride.cols;
-            this._rows = this._dimensionsOverride.rows;
-        }
-        this._dimensionsOverride = dimensions;
-        if (immediate) {
-            this._resizeNow(true);
-        }
-        else {
-            this._resize();
-        }
-    }
-    async setFixedDimensions() {
-        const cols = await this._quickInputService.input({
-            title: ( nls.localize('setTerminalDimensionsColumn', "Set Fixed Dimensions: Column")),
-            placeHolder: 'Enter a number of columns or leave empty for automatic width',
-            validateInput: async (text) => text.length > 0 && !text.match(/^\d+$/) ? { content: 'Enter a number or leave empty size automatically', severity: Severity.Error } : undefined
-        });
-        if (cols === undefined) {
-            return;
-        }
-        this._fixedCols = this._parseFixedDimension(cols);
-        this._labelComputer?.refreshLabel(this);
-        this._terminalHasFixedWidth.set(!!this._fixedCols);
-        const rows = await this._quickInputService.input({
-            title: ( nls.localize('setTerminalDimensionsRow', "Set Fixed Dimensions: Row")),
-            placeHolder: 'Enter a number of rows or leave empty for automatic height',
-            validateInput: async (text) => text.length > 0 && !text.match(/^\d+$/) ? { content: 'Enter a number or leave empty size automatically', severity: Severity.Error } : undefined
-        });
-        if (rows === undefined) {
-            return;
-        }
-        this._fixedRows = this._parseFixedDimension(rows);
-        this._labelComputer?.refreshLabel(this);
-        await this._refreshScrollbar();
-        this._resize();
-        this.focus();
-    }
-    _parseFixedDimension(value) {
-        if (value === '') {
-            return undefined;
-        }
-        const parsed = parseInt(value);
-        if (parsed <= 0) {
-            throw new Error(`Could not parse dimension "${value}"`);
-        }
-        return parsed;
-    }
-    async toggleSizeToContentWidth() {
-        if (!this.xterm?.raw.buffer.active) {
-            return;
-        }
-        if (this._hasScrollBar) {
-            this._terminalHasFixedWidth.set(false);
-            this._fixedCols = undefined;
-            this._fixedRows = undefined;
-            this._hasScrollBar = false;
-            this._initDimensions();
-            await this._resize();
-        }
-        else {
-            const proposedCols = Math.max(this.maxCols, Math.min(this.xterm.getLongestViewportWrappedLineLength(), 5000 ));
-            if (proposedCols > this.xterm.raw.cols) {
-                this._fixedCols = proposedCols;
-            }
-        }
-        await this._refreshScrollbar();
-        this._labelComputer?.refreshLabel(this);
-        this.focus();
-    }
-    _refreshScrollbar() {
-        if (this._fixedCols || this._fixedRows) {
-            return this._addScrollbar();
-        }
-        return this._removeScrollbar();
-    }
-    async _addScrollbar() {
-        const charWidth = (this.xterm ? this.xterm.getFont() : this._configHelper.getFont()).charWidth;
-        if (!this.xterm?.raw.element || !this._container || !charWidth || !this._fixedCols) {
-            return;
-        }
-        this._wrapperElement.classList.add('fixed-dims');
-        this._hasScrollBar = true;
-        this._initDimensions();
-        this._fixedRows = this._rows - 1;
-        await this._resize();
-        this._terminalHasFixedWidth.set(true);
-        if (!this._horizontalScrollbar) {
-            this._horizontalScrollbar = this._register(( new DomScrollableElement(this._wrapperElement, {
-                vertical: 2 ,
-                horizontal: 1 ,
-                useShadows: false,
-                scrollYToX: false,
-                consumeMouseWheelIfScrollbarIsNeeded: false
-            })));
-            this._container.appendChild(this._horizontalScrollbar.getDomNode());
-        }
-        this._horizontalScrollbar.setScrollDimensions({
-            width: this.xterm.raw.element.clientWidth,
-            scrollWidth: this._fixedCols * charWidth + 40
-        });
-        this._horizontalScrollbar.getDomNode().style.paddingBottom = '16px';
-        if (isWindows) {
-            for (let i = this.xterm.raw.buffer.active.viewportY; i < this.xterm.raw.buffer.active.length; i++) {
-                const line = this.xterm.raw.buffer.active.getLine(i);
-                line._line.isWrapped = false;
-            }
-        }
-    }
-    async _removeScrollbar() {
-        if (!this._container || !this._horizontalScrollbar) {
-            return;
-        }
-        this._horizontalScrollbar.getDomNode().remove();
-        this._horizontalScrollbar.dispose();
-        this._horizontalScrollbar = undefined;
-        this._wrapperElement.remove();
-        this._wrapperElement.classList.remove('fixed-dims');
-        this._container.appendChild(this._wrapperElement);
-    }
-    _setResolvedShellLaunchConfig(shellLaunchConfig) {
-        this._shellLaunchConfig.args = shellLaunchConfig.args;
-        this._shellLaunchConfig.cwd = shellLaunchConfig.cwd;
-        this._shellLaunchConfig.executable = shellLaunchConfig.executable;
-        this._shellLaunchConfig.env = shellLaunchConfig.env;
-    }
-    _onEnvironmentVariableInfoChanged(info) {
-        if (info.requiresAction) {
-            this.xterm?.raw.textarea?.setAttribute('aria-label', ( nls.localize(
-                'terminalStaleTextBoxAriaLabel',
-                "Terminal {0} environment is stale, run the 'Show Environment Information' command for more information",
-                this._instanceId
-            )));
-        }
-        this._refreshEnvironmentVariableInfoWidgetState(info);
-    }
-    async _refreshEnvironmentVariableInfoWidgetState(info) {
-        if (!info) {
-            this.statusList.remove("relaunch-needed" );
-            this.statusList.remove("env-var-info-changes-active" );
-            return;
-        }
-        if (
-        info.requiresAction &&
-            this._configHelper.config.environmentChangesRelaunch &&
-            !this._processManager.hasWrittenData &&
-            (!this._shellLaunchConfig.isFeatureTerminal || (this.reconnectionProperties && this._configurationService.getValue('task.reconnection') === true)) &&
-            !this._shellLaunchConfig.customPtyImplementation &&
-            !this._shellLaunchConfig.isExtensionOwnedTerminal &&
-            !this._shellLaunchConfig.attachPersistentProcess &&
-            !((this._processManager.remoteAuthority && this._configHelper.config.windowsEnableConpty && (await this._processManager.getBackendOS()) === 1) )) {
-            this.relaunch();
-            return;
-        }
-        const workspaceFolder = getWorkspaceForTerminal(this.shellLaunchConfig.cwd, this._workspaceContextService, this._historyService);
-        this.statusList.add(info.getStatus({ workspaceFolder }));
-    }
-    async getInitialCwd() {
-        if (!this._initialCwd) {
-            this._initialCwd = this._processManager.initialCwd;
-        }
-        return this._initialCwd;
-    }
-    async getCwd() {
-        if (( this.capabilities.has(0 ))) {
-            return this.capabilities.get(0 ).getCwd();
-        }
-        else if (( this.capabilities.has(1 ))) {
-            return this.capabilities.get(1 ).getCwd();
-        }
-        return this._processManager.initialCwd;
-    }
-    async _refreshProperty(type) {
-        await this.processReady;
-        return this._processManager.refreshProperty(type);
-    }
-    async _updateProperty(type, value) {
-        return this._processManager.updateProperty(type, value);
-    }
-    async rename(title) {
-        this._setTitle(title, TitleEventSource.Api);
-    }
-    _setTitle(title, eventSource) {
-        const reset = !title;
-        title = this._updateTitleProperties(title, eventSource);
-        const titleChanged = title !== this._title;
-        this._title = title;
-        this._labelComputer?.refreshLabel(this, reset);
-        this._setAriaLabel(this.xterm?.raw, this._instanceId, this._title);
-        if (titleChanged) {
-            this._onTitleChanged.fire(this);
-        }
-    }
-    async changeIcon() {
-        const items = [];
-        for (const icon of getAllCodicons()) {
-            items.push({ label: `$(${icon.id})`, description: `${icon.id}`, icon });
-        }
-        const result = await this._quickInputService.pick(items, {
-            matchOnDescription: true
-        });
-        if (result) {
-            this._icon = result.icon;
-            this._onIconChanged.fire({ instance: this, userInitiated: true });
-        }
-    }
-    async changeColor() {
-        const icon = this._getIcon();
-        if (!icon) {
-            return;
-        }
-        const colorTheme = this._themeService.getColorTheme();
-        const standardColors = getStandardColors(colorTheme);
-        const styleElement = getColorStyleElement(colorTheme);
-        const items = [];
-        for (const colorKey of standardColors) {
-            const colorClass = getColorClass(colorKey);
-            items.push({
-                label: `$(${Codicon.circleFilled.id}) ${colorKey.replace('terminal.ansi', '')}`, id: colorKey, description: colorKey, iconClasses: [colorClass]
-            });
-        }
-        items.push({ type: 'separator' });
-        const showAllColorsItem = { label: 'Reset to default' };
-        items.push(showAllColorsItem);
-        document.body.appendChild(styleElement);
-        const quickPick = this._quickInputService.createQuickPick();
-        quickPick.items = items;
-        quickPick.matchOnDescription = true;
-        quickPick.show();
-        const disposables = [];
-        const result = await ( new Promise(r => {
-            disposables.push(quickPick.onDidHide(() => r(undefined)));
-            disposables.push(quickPick.onDidAccept(() => r(quickPick.selectedItems[0])));
-        }));
-        dispose(disposables);
-        if (result) {
-            this.shellLaunchConfig.color = result.id;
-            this._onIconChanged.fire({ instance: this, userInitiated: true });
-        }
-        quickPick.hide();
-        document.body.removeChild(styleElement);
-    }
-    selectPreviousSuggestion() {
-        this.xterm?.suggestController?.selectPreviousSuggestion();
-    }
-    selectPreviousPageSuggestion() {
-        this.xterm?.suggestController?.selectPreviousPageSuggestion();
-    }
-    selectNextSuggestion() {
-        this.xterm?.suggestController?.selectNextSuggestion();
-    }
-    selectNextPageSuggestion() {
-        this.xterm?.suggestController?.selectNextPageSuggestion();
-    }
-    async acceptSelectedSuggestion(suggestion) {
-        this.xterm?.suggestController?.acceptSelectedSuggestion(suggestion);
-    }
-    hideSuggestWidget() {
-        this.xterm?.suggestController?.hideSuggestWidget();
-    }
-    forceScrollbarVisibility() {
-        this._wrapperElement.classList.add('force-scrollbar');
-    }
-    resetScrollbarVisibility() {
-        this._wrapperElement.classList.remove('force-scrollbar');
-    }
-};
-TerminalInstance.__decorator = ( __decorate([
-    debounce(50)
-], TerminalInstance.prototype, "_fireMaximumDimensionsChanged", null));
-TerminalInstance.__decorator = ( __decorate([
-    debounce(1000)
-], TerminalInstance.prototype, "relaunch", null));
-TerminalInstance.__decorator = ( __decorate([
-    debounce(2000)
-], TerminalInstance.prototype, "_updateProcessCwd", null));
-TerminalInstance.__decorator = ( __decorate([
-    debounce(50)
-], TerminalInstance.prototype, "_resize", null));
-TerminalInstance = TerminalInstance_1 = ( __decorate([
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, ITerminalProfileResolverService)),
-    ( __param(8, IPathService)),
-    ( __param(9, IKeybindingService)),
-    ( __param(10, INotificationService)),
-    ( __param(11, IPreferencesService)),
-    ( __param(12, IViewsService)),
-    ( __param(13, IClipboardService)),
-    ( __param(14, IThemeService)),
-    ( __param(15, IConfigurationService)),
-    ( __param(16, ITerminalLogService)),
-    ( __param(17, IDialogService)),
-    ( __param(18, IStorageService)),
-    ( __param(19, IAccessibilityService)),
-    ( __param(20, IProductService)),
-    ( __param(21, IQuickInputService)),
-    ( __param(22, IWorkbenchEnvironmentService)),
-    ( __param(23, IWorkspaceContextService)),
-    ( __param(24, IEditorService)),
-    ( __param(25, IWorkspaceTrustRequestService)),
-    ( __param(26, IHistoryService)),
-    ( __param(27, ITelemetryService)),
-    ( __param(28, IOpenerService)),
-    ( __param(29, ICommandService)),
-    ( __param(30, IAudioCueService)),
-    ( __param(31, IViewDescriptorService))
-], TerminalInstance));
-let TerminalInstanceDragAndDropController = class TerminalInstanceDragAndDropController extends Disposable {
-    get onDropFile() { return this._onDropFile.event; }
-    get onDropTerminal() { return this._onDropTerminal.event; }
-    constructor(_container, _layoutService, _viewDescriptorService) {
-        super();
-        this._container = _container;
-        this._layoutService = _layoutService;
-        this._viewDescriptorService = _viewDescriptorService;
-        this._onDropFile = this._register(( new Emitter()));
-        this._onDropTerminal = this._register(( new Emitter()));
-        this._register(toDisposable(() => this._clearDropOverlay()));
-    }
-    _clearDropOverlay() {
-        if (this._dropOverlay && this._dropOverlay.parentElement) {
-            this._dropOverlay.parentElement.removeChild(this._dropOverlay);
-        }
-        this._dropOverlay = undefined;
-    }
-    onDragEnter(e) {
-        if (!containsDragType(e, DataTransfers.FILES, DataTransfers.RESOURCES, "Terminals" , CodeDataTransfers.FILES)) {
-            return;
-        }
-        if (!this._dropOverlay) {
-            this._dropOverlay = document.createElement('div');
-            this._dropOverlay.classList.add('terminal-drop-overlay');
-        }
-        if (containsDragType(e, "Terminals" )) {
-            const side = this._getDropSide(e);
-            this._dropOverlay.classList.toggle('drop-before', side === 'before');
-            this._dropOverlay.classList.toggle('drop-after', side === 'after');
-        }
-        if (!this._dropOverlay.parentElement) {
-            this._container.appendChild(this._dropOverlay);
-        }
-    }
-    onDragLeave(e) {
-        this._clearDropOverlay();
-    }
-    onDragEnd(e) {
-        this._clearDropOverlay();
-    }
-    onDragOver(e) {
-        if (!e.dataTransfer || !this._dropOverlay) {
-            return;
-        }
-        if (containsDragType(e, "Terminals" )) {
-            const side = this._getDropSide(e);
-            this._dropOverlay.classList.toggle('drop-before', side === 'before');
-            this._dropOverlay.classList.toggle('drop-after', side === 'after');
-        }
-        this._dropOverlay.style.opacity = '1';
-    }
-    async onDrop(e) {
-        this._clearDropOverlay();
-        if (!e.dataTransfer) {
-            return;
-        }
-        const terminalResources = getTerminalResourcesFromDragEvent(e);
-        if (terminalResources) {
-            for (const uri of terminalResources) {
-                const side = this._getDropSide(e);
-                this._onDropTerminal.fire({ uri, side });
-            }
-            return;
-        }
-        let path;
-        const rawResources = e.dataTransfer.getData(DataTransfers.RESOURCES);
-        if (rawResources) {
-            path = ( URI.parse(JSON.parse(rawResources)[0]));
-        }
-        const rawCodeFiles = e.dataTransfer.getData(CodeDataTransfers.FILES);
-        if (!path && rawCodeFiles) {
-            path = URI.file(JSON.parse(rawCodeFiles)[0]);
-        }
-        if (!path && e.dataTransfer.files.length > 0 && e.dataTransfer.files[0].path ) {
-            path = URI.file(e.dataTransfer.files[0].path);
-        }
-        if (!path) {
-            return;
-        }
-        this._onDropFile.fire(path);
-    }
-    _getDropSide(e) {
-        const target = this._container;
-        if (!target) {
-            return 'after';
-        }
-        const rect = target.getBoundingClientRect();
-        return this._getViewOrientation() === 1
-            ? (e.clientX - rect.left < rect.width / 2 ? 'before' : 'after')
-            : (e.clientY - rect.top < rect.height / 2 ? 'before' : 'after');
-    }
-    _getViewOrientation() {
-        const panelPosition = this._layoutService.getPanelPosition();
-        const terminalLocation = this._viewDescriptorService.getViewLocationById(TERMINAL_VIEW_ID);
-        return terminalLocation === 1  && panelPosition === 2
-            ? 1
-            : 0 ;
-    }
-};
-TerminalInstanceDragAndDropController = ( __decorate([
-    ( __param(1, IWorkbenchLayoutService)),
-    ( __param(2, IViewDescriptorService))
-], TerminalInstanceDragAndDropController));
-let TerminalLabelComputer = class TerminalLabelComputer extends Disposable {
-    get title() { return this._title; }
-    get description() { return this._description; }
-    constructor(_configHelper, _fileService, _workspaceContextService) {
-        super();
-        this._configHelper = _configHelper;
-        this._fileService = _fileService;
-        this._workspaceContextService = _workspaceContextService;
-        this._title = '';
-        this._description = '';
-        this._onDidChangeLabel = this._register(( new Emitter()));
-        this.onDidChangeLabel = this._onDidChangeLabel.event;
-    }
-    refreshLabel(instance, reset) {
-        this._title = this.computeLabel(instance, this._configHelper.config.tabs.title, "title" , reset);
-        this._description = this.computeLabel(instance, this._configHelper.config.tabs.description, "description" );
-        if (this._title !== instance.title || this._description !== instance.description || reset) {
-            this._onDidChangeLabel.fire({ title: this._title, description: this._description });
-        }
-    }
-    computeLabel(instance, labelTemplate, labelType, reset) {
-        const type = instance.shellLaunchConfig.attachPersistentProcess?.type || instance.shellLaunchConfig.type;
-        const templateProperties = {
-            cwd: instance.cwd || instance.initialCwd || '',
-            cwdFolder: '',
-            workspaceFolder: instance.workspaceFolder ? path.basename(instance.workspaceFolder.uri.fsPath) : undefined,
-            local: type === 'Local' ? type : undefined,
-            process: instance.processName,
-            sequence: instance.sequence,
-            task: type === 'Task' ? type : undefined,
-            fixedDimensions: instance.fixedCols
-                ? (instance.fixedRows ? `\u2194${instance.fixedCols} \u2195${instance.fixedRows}` : `\u2194${instance.fixedCols}`)
-                : (instance.fixedRows ? `\u2195${instance.fixedRows}` : ''),
-            separator: { label: this._configHelper.config.tabs.separator }
-        };
-        labelTemplate = labelTemplate.trim();
-        if (!labelTemplate) {
-            return labelType === "title"  ? (instance.processName || '') : '';
-        }
-        if (!reset && instance.staticTitle && labelType === "title" ) {
-            return instance.staticTitle.replace(/[\n\r\t]/g, '') || templateProperties.process?.replace(/[\n\r\t]/g, '') || '';
-        }
-        const detection = ( instance.capabilities.has(0 )) || ( instance.capabilities.has(1 ));
-        const folders = this._workspaceContextService.getWorkspace().folders;
-        const multiRootWorkspace = folders.length > 1;
-        if (templateProperties.cwd && detection && ((!instance.shellLaunchConfig.isFeatureTerminal || labelType === "title") )) {
-            const cwdUri = ( URI.from({
-                scheme: instance.workspaceFolder?.uri.scheme || Schemas.file,
-                path: instance.cwd ? path.resolve(instance.cwd) : undefined
-            }));
-            let showCwd = false;
-            if (multiRootWorkspace) {
-                showCwd = true;
-            }
-            else if (instance.workspaceFolder?.uri) {
-                const caseSensitive = this._fileService.hasCapability(instance.workspaceFolder.uri, 1024 );
-                showCwd = cwdUri.fsPath.localeCompare(instance.workspaceFolder.uri.fsPath, undefined, { sensitivity: caseSensitive ? 'case' : 'base' }) !== 0;
-            }
-            if (showCwd) {
-                templateProperties.cwdFolder = path.basename(templateProperties.cwd);
-            }
-        }
-        const label = template(labelTemplate, templateProperties).replace(/[\n\r\t]/g, '').trim();
-        return label === '' && labelType === "title"  ? (instance.processName || '') : label;
-    }
-};
-TerminalLabelComputer = ( __decorate([
-    ( __param(1, IFileService)),
-    ( __param(2, IWorkspaceContextService))
-], TerminalLabelComputer));
-function parseExitResult(exitCodeOrError, shellLaunchConfig, processState, initialCwd) {
-    if (exitCodeOrError === undefined || exitCodeOrError === 0) {
-        return { code: exitCodeOrError, message: undefined };
-    }
-    const code = typeof exitCodeOrError === 'number' ? exitCodeOrError : exitCodeOrError.code;
-    let message = undefined;
-    switch (typeof exitCodeOrError) {
-        case 'number': {
-            let commandLine = undefined;
-            if (shellLaunchConfig.executable) {
-                commandLine = shellLaunchConfig.executable;
-                if (typeof shellLaunchConfig.args === 'string') {
-                    commandLine += ` ${shellLaunchConfig.args}`;
-                }
-                else if (shellLaunchConfig.args && shellLaunchConfig.args.length) {
-                    commandLine += ( shellLaunchConfig.args.map(a => ` '${a}'`)).join();
-                }
-            }
-            if (processState === 4 ) {
-                if (commandLine) {
-                    message = ( nls.localize(
-                        'launchFailed.exitCodeAndCommandLine',
-                        "The terminal process \"{0}\" failed to launch (exit code: {1}).",
-                        commandLine,
-                        code
-                    ));
-                }
-                else {
-                    message = ( nls.localize(
-                        'launchFailed.exitCodeOnly',
-                        "The terminal process failed to launch (exit code: {0}).",
-                        code
-                    ));
-                }
-            }
-            else {
-                if (commandLine) {
-                    message = ( nls.localize(
-                        'terminated.exitCodeAndCommandLine',
-                        "The terminal process \"{0}\" terminated with exit code: {1}.",
-                        commandLine,
-                        code
-                    ));
-                }
-                else {
-                    message = ( nls.localize(
-                        'terminated.exitCodeOnly',
-                        "The terminal process terminated with exit code: {0}.",
-                        code
-                    ));
-                }
-            }
-            break;
-        }
-        case 'object': {
-            if (( exitCodeOrError.message.toString()).includes('Could not find pty with id')) {
-                break;
-            }
-            let innerMessage = exitCodeOrError.message;
-            const conptyError = exitCodeOrError.message.match(/.*error code:\s*(\d+).*$/);
-            if (conptyError) {
-                const errorCode = conptyError.length > 1 ? parseInt(conptyError[1]) : undefined;
-                switch (errorCode) {
-                    case 5:
-                        innerMessage = `Access was denied to the path containing your executable "${shellLaunchConfig.executable}". Manage and change your permissions to get this to work`;
-                        break;
-                    case 267:
-                        innerMessage = `Invalid starting directory "${initialCwd}", review your terminal.integrated.cwd setting`;
-                        break;
-                    case 1260:
-                        innerMessage = `Windows cannot open this program because it has been prevented by a software restriction policy. For more information, open Event Viewer or contact your system Administrator`;
-                        break;
-                }
-            }
-            message = ( nls.localize(
-                'launchFailed.errorMessage',
-                "The terminal process failed to launch: {0}.",
-                innerMessage
-            ));
-            break;
-        }
-    }
-    return { code, message };
-}
-export { TerminalInstance, TerminalLabelComputer, parseExitResult };